lib/libopenh323/src/h248.cxx

   1 //
   2 // h248.cxx
   3 //
   4 // Code automatically generated by asnparse.
   5 //
   6
   7 #ifdef P_USE_PRAGMA
   8 #pragma implementation "h248.h"
   9 #endif
  10
  11 #include <ptlib.h>
  12 #include "h248.h"
  13
  14 #define new PNEW
  15
  16
  17 #if ! H323_DISABLE_H248
  18
  19 //
  20 // SecurityParmIndex
  21 //
  22
  23 H248_SecurityParmIndex::H248_SecurityParmIndex(unsigned tag, PASN_Object::TagClass tagClass)
  24   : PASN_OctetString(tag, tagClass)
  25 {
  26   SetConstraints(PASN_Object::FixedConstraint, 4);
  27 }
  28
  29
  30 H248_SecurityParmIndex::H248_SecurityParmIndex(const char * v)
  31 {
  32   SetValue(v);
  33 }
  34
  35
  36 H248_SecurityParmIndex::H248_SecurityParmIndex(const PString & v)
  37 {
  38   SetValue(v);
  39 }
  40
  41
  42 H248_SecurityParmIndex::H248_SecurityParmIndex(const PBYTEArray & v)
  43 {
  44   SetValue(v);
  45 }
  46
  47
  48 H248_SecurityParmIndex & H248_SecurityParmIndex::operator=(const char * v)
  49 {
  50   SetValue(v);
  51   return *this;
  52 }
  53
  54
  55 H248_SecurityParmIndex & H248_SecurityParmIndex::operator=(const PString & v)
  56 {
  57   SetValue(v);
  58   return *this;
  59 }
  60
  61
  62 H248_SecurityParmIndex & H248_SecurityParmIndex::operator=(const PBYTEArray & v)
  63 {
  64   SetValue(v);
  65   return *this;
  66 }
  67
  68
  69 PObject * H248_SecurityParmIndex::Clone() const
  70 {
  71 #ifndef PASN_LEANANDMEAN
  72   PAssert(IsClass(H248_SecurityParmIndex::Class()), PInvalidCast);
  73 #endif
  74   return new H248_SecurityParmIndex(*this);
  75 }
  76
  77
  78 //
  79 // SequenceNum
  80 //
  81
  82 H248_SequenceNum::H248_SequenceNum(unsigned tag, PASN_Object::TagClass tagClass)
  83   : PASN_OctetString(tag, tagClass)
  84 {
  85   SetConstraints(PASN_Object::FixedConstraint, 4);
  86 }
  87
  88
  89 H248_SequenceNum::H248_SequenceNum(const char * v)
  90 {
  91   SetValue(v);
  92 }
  93
  94
  95 H248_SequenceNum::H248_SequenceNum(const PString & v)
  96 {
  97   SetValue(v);
  98 }
  99
 100
 101 H248_SequenceNum::H248_SequenceNum(const PBYTEArray & v)
 102 {
 103   SetValue(v);
 104 }
 105
 106
 107 H248_SequenceNum & H248_SequenceNum::operator=(const char * v)
 108 {
 109   SetValue(v);
 110   return *this;
 111 }
 112
 113
 114 H248_SequenceNum & H248_SequenceNum::operator=(const PString & v)
 115 {
 116   SetValue(v);
 117   return *this;
 118 }
 119
 120
 121 H248_SequenceNum & H248_SequenceNum::operator=(const PBYTEArray & v)
 122 {
 123   SetValue(v);
 124   return *this;
 125 }
 126
 127
 128 PObject * H248_SequenceNum::Clone() const
 129 {
 130 #ifndef PASN_LEANANDMEAN
 131   PAssert(IsClass(H248_SequenceNum::Class()), PInvalidCast);
 132 #endif
 133   return new H248_SequenceNum(*this);
 134 }
 135
 136
 137 //
 138 // AuthData
 139 //
 140
 141 H248_AuthData::H248_AuthData(unsigned tag, PASN_Object::TagClass tagClass)
 142   : PASN_OctetString(tag, tagClass)
 143 {
 144   SetConstraints(PASN_Object::FixedConstraint, 12, 32);
 145 }
 146
 147
 148 H248_AuthData::H248_AuthData(const char * v)
 149 {
 150   SetValue(v);
 151 }
 152
 153
 154 H248_AuthData::H248_AuthData(const PString & v)
 155 {
 156   SetValue(v);
 157 }
 158
 159
 160 H248_AuthData::H248_AuthData(const PBYTEArray & v)
 161 {
 162   SetValue(v);
 163 }
 164
 165
 166 H248_AuthData & H248_AuthData::operator=(const char * v)
 167 {
 168   SetValue(v);
 169   return *this;
 170 }
 171
 172
 173 H248_AuthData & H248_AuthData::operator=(const PString & v)
 174 {
 175   SetValue(v);
 176   return *this;
 177 }
 178
 179
 180 H248_AuthData & H248_AuthData::operator=(const PBYTEArray & v)
 181 {
 182   SetValue(v);
 183   return *this;
 184 }
 185
 186
 187 PObject * H248_AuthData::Clone() const
 188 {
 189 #ifndef PASN_LEANANDMEAN
 190   PAssert(IsClass(H248_AuthData::Class()), PInvalidCast);
 191 #endif
 192   return new H248_AuthData(*this);
 193 }
 194
 195
 196
 197 #ifndef PASN_NOPRINTON
 198 const static PASN_Names Names_H248_MId[]={
 199       {"ip4Address",0}
 200      ,{"ip6Address",1}
 201      ,{"domainName",2}
 202      ,{"deviceName",3}
 203      ,{"mtpAddress",4}
 204 };
 205 #endif
 206 //
 207 // MId
 208 //
 209
 210 H248_MId::H248_MId(unsigned tag, PASN_Object::TagClass tagClass)
 211   : PASN_Choice(tag, tagClass, 5, TRUE
 212 #ifndef PASN_NOPRINTON
 213     ,(const PASN_Names *)Names_H248_MId,5
 214 #endif
 215 )
 216 {
 217 }
 218
 219
 220 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 221 H248_MId::operator H248_IP4Address &() const
 222 #else
 223 H248_MId::operator H248_IP4Address &()
 224 {
 225 #ifndef PASN_LEANANDMEAN
 226   PAssert(PIsDescendant(PAssertNULL(choice), H248_IP4Address), PInvalidCast);
 227 #endif
 228   return *(H248_IP4Address *)choice;
 229 }
 230
 231
 232 H248_MId::operator const H248_IP4Address &() const
 233 #endif
 234 {
 235 #ifndef PASN_LEANANDMEAN
 236   PAssert(PIsDescendant(PAssertNULL(choice), H248_IP4Address), PInvalidCast);
 237 #endif
 238   return *(H248_IP4Address *)choice;
 239 }
 240
 241
 242 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 243 H248_MId::operator H248_IP6Address &() const
 244 #else
 245 H248_MId::operator H248_IP6Address &()
 246 {
 247 #ifndef PASN_LEANANDMEAN
 248   PAssert(PIsDescendant(PAssertNULL(choice), H248_IP6Address), PInvalidCast);
 249 #endif
 250   return *(H248_IP6Address *)choice;
 251 }
 252
 253
 254 H248_MId::operator const H248_IP6Address &() const
 255 #endif
 256 {
 257 #ifndef PASN_LEANANDMEAN
 258   PAssert(PIsDescendant(PAssertNULL(choice), H248_IP6Address), PInvalidCast);
 259 #endif
 260   return *(H248_IP6Address *)choice;
 261 }
 262
 263
 264 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 265 H248_MId::operator H248_DomainName &() const
 266 #else
 267 H248_MId::operator H248_DomainName &()
 268 {
 269 #ifndef PASN_LEANANDMEAN
 270   PAssert(PIsDescendant(PAssertNULL(choice), H248_DomainName), PInvalidCast);
 271 #endif
 272   return *(H248_DomainName *)choice;
 273 }
 274
 275
 276 H248_MId::operator const H248_DomainName &() const
 277 #endif
 278 {
 279 #ifndef PASN_LEANANDMEAN
 280   PAssert(PIsDescendant(PAssertNULL(choice), H248_DomainName), PInvalidCast);
 281 #endif
 282   return *(H248_DomainName *)choice;
 283 }
 284
 285
 286 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 287 H248_MId::operator H248_PathName &() const
 288 #else
 289 H248_MId::operator H248_PathName &()
 290 {
 291 #ifndef PASN_LEANANDMEAN
 292   PAssert(PIsDescendant(PAssertNULL(choice), H248_PathName), PInvalidCast);
 293 #endif
 294   return *(H248_PathName *)choice;
 295 }
 296
 297
 298 H248_MId::operator const H248_PathName &() const
 299 #endif
 300 {
 301 #ifndef PASN_LEANANDMEAN
 302   PAssert(PIsDescendant(PAssertNULL(choice), H248_PathName), PInvalidCast);
 303 #endif
 304   return *(H248_PathName *)choice;
 305 }
 306
 307
 308 BOOL H248_MId::CreateObject()
 309 {
 310   switch (tag) {
 311     case e_ip4Address :
 312       choice = new H248_IP4Address();
 313       return TRUE;
 314     case e_ip6Address :
 315       choice = new H248_IP6Address();
 316       return TRUE;
 317     case e_domainName :
 318       choice = new H248_DomainName();
 319       return TRUE;
 320     case e_deviceName :
 321       choice = new H248_PathName();
 322       return TRUE;
 323     case e_mtpAddress :
 324       choice = new PASN_OctetString();
 325       choice->SetConstraints(PASN_Object::FixedConstraint, 2, 4);
 326       return TRUE;
 327   }
 328
 329   choice = NULL;
 330   return FALSE;
 331 }
 332
 333
 334 PObject * H248_MId::Clone() const
 335 {
 336 #ifndef PASN_LEANANDMEAN
 337   PAssert(IsClass(H248_MId::Class()), PInvalidCast);
 338 #endif
 339   return new H248_MId(*this);
 340 }
 341
 342
 343 //
 344 // DomainName
 345 //
 346
 347 H248_DomainName::H248_DomainName(unsigned tag, PASN_Object::TagClass tagClass)
 348   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
 349 {
 350   m_portNumber.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
 351 }
 352
 353
 354 #ifndef PASN_NOPRINTON
 355 void H248_DomainName::PrintOn(ostream & strm) const
 356 {
 357   int indent = strm.precision() + 2;
 358   strm << "{\n";
 359   strm << setw(indent+7) << "name = " << setprecision(indent) << m_name << '\n';
 360   if (HasOptionalField(e_portNumber))
 361     strm << setw(indent+13) << "portNumber = " << setprecision(indent) << m_portNumber << '\n';
 362   strm << setw(indent-1) << setprecision(indent-2) << "}";
 363 }
 364 #endif
 365
 366
 367 PObject::Comparison H248_DomainName::Compare(const PObject & obj) const
 368 {
 369 #ifndef PASN_LEANANDMEAN
 370   PAssert(PIsDescendant(&obj, H248_DomainName), PInvalidCast);
 371 #endif
 372   const H248_DomainName & other = (const H248_DomainName &)obj;
 373
 374   Comparison result;
 375
 376   if ((result = m_name.Compare(other.m_name)) != EqualTo)
 377     return result;
 378   if ((result = m_portNumber.Compare(other.m_portNumber)) != EqualTo)
 379     return result;
 380
 381   return PASN_Sequence::Compare(other);
 382 }
 383
 384
 385 PINDEX H248_DomainName::GetDataLength() const
 386 {
 387   PINDEX length = 0;
 388   length += m_name.GetObjectLength();
 389   if (HasOptionalField(e_portNumber))
 390     length += m_portNumber.GetObjectLength();
 391   return length;
 392 }
 393
 394
 395 BOOL H248_DomainName::Decode(PASN_Stream & strm)
 396 {
 397   if (!PreambleDecode(strm))
 398     return FALSE;
 399
 400   if (!m_name.Decode(strm))
 401     return FALSE;
 402   if (HasOptionalField(e_portNumber) && !m_portNumber.Decode(strm))
 403     return FALSE;
 404
 405   return UnknownExtensionsDecode(strm);
 406 }
 407
 408
 409 void H248_DomainName::Encode(PASN_Stream & strm) const
 410 {
 411   PreambleEncode(strm);
 412
 413   m_name.Encode(strm);
 414   if (HasOptionalField(e_portNumber))
 415     m_portNumber.Encode(strm);
 416
 417   UnknownExtensionsEncode(strm);
 418 }
 419
 420
 421 PObject * H248_DomainName::Clone() const
 422 {
 423 #ifndef PASN_LEANANDMEAN
 424   PAssert(IsClass(H248_DomainName::Class()), PInvalidCast);
 425 #endif
 426   return new H248_DomainName(*this);
 427 }
 428
 429
 430 //
 431 // IP4Address
 432 //
 433
 434 H248_IP4Address::H248_IP4Address(unsigned tag, PASN_Object::TagClass tagClass)
 435   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
 436 {
 437   m_address.SetConstraints(PASN_Object::FixedConstraint, 4);
 438   m_portNumber.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
 439 }
 440
 441
 442 #ifndef PASN_NOPRINTON
 443 void H248_IP4Address::PrintOn(ostream & strm) const
 444 {
 445   int indent = strm.precision() + 2;
 446   strm << "{\n";
 447   strm << setw(indent+10) << "address = " << setprecision(indent) << m_address << '\n';
 448   if (HasOptionalField(e_portNumber))
 449     strm << setw(indent+13) << "portNumber = " << setprecision(indent) << m_portNumber << '\n';
 450   strm << setw(indent-1) << setprecision(indent-2) << "}";
 451 }
 452 #endif
 453
 454
 455 PObject::Comparison H248_IP4Address::Compare(const PObject & obj) const
 456 {
 457 #ifndef PASN_LEANANDMEAN
 458   PAssert(PIsDescendant(&obj, H248_IP4Address), PInvalidCast);
 459 #endif
 460   const H248_IP4Address & other = (const H248_IP4Address &)obj;
 461
 462   Comparison result;
 463
 464   if ((result = m_address.Compare(other.m_address)) != EqualTo)
 465     return result;
 466   if ((result = m_portNumber.Compare(other.m_portNumber)) != EqualTo)
 467     return result;
 468
 469   return PASN_Sequence::Compare(other);
 470 }
 471
 472
 473 PINDEX H248_IP4Address::GetDataLength() const
 474 {
 475   PINDEX length = 0;
 476   length += m_address.GetObjectLength();
 477   if (HasOptionalField(e_portNumber))
 478     length += m_portNumber.GetObjectLength();
 479   return length;
 480 }
 481
 482
 483 BOOL H248_IP4Address::Decode(PASN_Stream & strm)
 484 {
 485   if (!PreambleDecode(strm))
 486     return FALSE;
 487
 488   if (!m_address.Decode(strm))
 489     return FALSE;
 490   if (HasOptionalField(e_portNumber) && !m_portNumber.Decode(strm))
 491     return FALSE;
 492
 493   return UnknownExtensionsDecode(strm);
 494 }
 495
 496
 497 void H248_IP4Address::Encode(PASN_Stream & strm) const
 498 {
 499   PreambleEncode(strm);
 500
 501   m_address.Encode(strm);
 502   if (HasOptionalField(e_portNumber))
 503     m_portNumber.Encode(strm);
 504
 505   UnknownExtensionsEncode(strm);
 506 }
 507
 508
 509 PObject * H248_IP4Address::Clone() const
 510 {
 511 #ifndef PASN_LEANANDMEAN
 512   PAssert(IsClass(H248_IP4Address::Class()), PInvalidCast);
 513 #endif
 514   return new H248_IP4Address(*this);
 515 }
 516
 517
 518 //
 519 // IP6Address
 520 //
 521
 522 H248_IP6Address::H248_IP6Address(unsigned tag, PASN_Object::TagClass tagClass)
 523   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
 524 {
 525   m_address.SetConstraints(PASN_Object::FixedConstraint, 16);
 526   m_portNumber.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
 527 }
 528
 529
 530 #ifndef PASN_NOPRINTON
 531 void H248_IP6Address::PrintOn(ostream & strm) const
 532 {
 533   int indent = strm.precision() + 2;
 534   strm << "{\n";
 535   strm << setw(indent+10) << "address = " << setprecision(indent) << m_address << '\n';
 536   if (HasOptionalField(e_portNumber))
 537     strm << setw(indent+13) << "portNumber = " << setprecision(indent) << m_portNumber << '\n';
 538   strm << setw(indent-1) << setprecision(indent-2) << "}";
 539 }
 540 #endif
 541
 542
 543 PObject::Comparison H248_IP6Address::Compare(const PObject & obj) const
 544 {
 545 #ifndef PASN_LEANANDMEAN
 546   PAssert(PIsDescendant(&obj, H248_IP6Address), PInvalidCast);
 547 #endif
 548   const H248_IP6Address & other = (const H248_IP6Address &)obj;
 549
 550   Comparison result;
 551
 552   if ((result = m_address.Compare(other.m_address)) != EqualTo)
 553     return result;
 554   if ((result = m_portNumber.Compare(other.m_portNumber)) != EqualTo)
 555     return result;
 556
 557   return PASN_Sequence::Compare(other);
 558 }
 559
 560
 561 PINDEX H248_IP6Address::GetDataLength() const
 562 {
 563   PINDEX length = 0;
 564   length += m_address.GetObjectLength();
 565   if (HasOptionalField(e_portNumber))
 566     length += m_portNumber.GetObjectLength();
 567   return length;
 568 }
 569
 570
 571 BOOL H248_IP6Address::Decode(PASN_Stream & strm)
 572 {
 573   if (!PreambleDecode(strm))
 574     return FALSE;
 575
 576   if (!m_address.Decode(strm))
 577     return FALSE;
 578   if (HasOptionalField(e_portNumber) && !m_portNumber.Decode(strm))
 579     return FALSE;
 580
 581   return UnknownExtensionsDecode(strm);
 582 }
 583
 584
 585 void H248_IP6Address::Encode(PASN_Stream & strm) const
 586 {
 587   PreambleEncode(strm);
 588
 589   m_address.Encode(strm);
 590   if (HasOptionalField(e_portNumber))
 591     m_portNumber.Encode(strm);
 592
 593   UnknownExtensionsEncode(strm);
 594 }
 595
 596
 597 PObject * H248_IP6Address::Clone() const
 598 {
 599 #ifndef PASN_LEANANDMEAN
 600   PAssert(IsClass(H248_IP6Address::Class()), PInvalidCast);
 601 #endif
 602   return new H248_IP6Address(*this);
 603 }
 604
 605
 606 //
 607 // PathName
 608 //
 609
 610 H248_PathName::H248_PathName(unsigned tag, PASN_Object::TagClass tagClass)
 611   : PASN_IA5String(tag, tagClass)
 612 {
 613   SetConstraints(PASN_Object::FixedConstraint, 1, 64);
 614 }
 615
 616
 617 H248_PathName & H248_PathName::operator=(const char * v)
 618 {
 619   SetValue(v);
 620   return *this;
 621 }
 622
 623
 624 H248_PathName & H248_PathName::operator=(const PString & v)
 625 {
 626   SetValue(v);
 627   return *this;
 628 }
 629
 630
 631 PObject * H248_PathName::Clone() const
 632 {
 633 #ifndef PASN_LEANANDMEAN
 634   PAssert(IsClass(H248_PathName::Class()), PInvalidCast);
 635 #endif
 636   return new H248_PathName(*this);
 637 }
 638
 639
 640
 641 #ifndef PASN_NOPRINTON
 642 const static PASN_Names Names_H248_Transaction[]={
 643       {"transactionRequest",0}
 644      ,{"transactionPending",1}
 645      ,{"transactionReply",2}
 646      ,{"transactionResponseAck",3}
 647 };
 648 #endif
 649 //
 650 // Transaction
 651 //
 652
 653 H248_Transaction::H248_Transaction(unsigned tag, PASN_Object::TagClass tagClass)
 654   : PASN_Choice(tag, tagClass, 4, TRUE
 655 #ifndef PASN_NOPRINTON
 656     ,(const PASN_Names *)Names_H248_Transaction,4
 657 #endif
 658 )
 659 {
 660 }
 661
 662
 663 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 664 H248_Transaction::operator H248_TransactionRequest &() const
 665 #else
 666 H248_Transaction::operator H248_TransactionRequest &()
 667 {
 668 #ifndef PASN_LEANANDMEAN
 669   PAssert(PIsDescendant(PAssertNULL(choice), H248_TransactionRequest), PInvalidCast);
 670 #endif
 671   return *(H248_TransactionRequest *)choice;
 672 }
 673
 674
 675 H248_Transaction::operator const H248_TransactionRequest &() const
 676 #endif
 677 {
 678 #ifndef PASN_LEANANDMEAN
 679   PAssert(PIsDescendant(PAssertNULL(choice), H248_TransactionRequest), PInvalidCast);
 680 #endif
 681   return *(H248_TransactionRequest *)choice;
 682 }
 683
 684
 685 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 686 H248_Transaction::operator H248_TransactionPending &() const
 687 #else
 688 H248_Transaction::operator H248_TransactionPending &()
 689 {
 690 #ifndef PASN_LEANANDMEAN
 691   PAssert(PIsDescendant(PAssertNULL(choice), H248_TransactionPending), PInvalidCast);
 692 #endif
 693   return *(H248_TransactionPending *)choice;
 694 }
 695
 696
 697 H248_Transaction::operator const H248_TransactionPending &() const
 698 #endif
 699 {
 700 #ifndef PASN_LEANANDMEAN
 701   PAssert(PIsDescendant(PAssertNULL(choice), H248_TransactionPending), PInvalidCast);
 702 #endif
 703   return *(H248_TransactionPending *)choice;
 704 }
 705
 706
 707 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 708 H248_Transaction::operator H248_TransactionReply &() const
 709 #else
 710 H248_Transaction::operator H248_TransactionReply &()
 711 {
 712 #ifndef PASN_LEANANDMEAN
 713   PAssert(PIsDescendant(PAssertNULL(choice), H248_TransactionReply), PInvalidCast);
 714 #endif
 715   return *(H248_TransactionReply *)choice;
 716 }
 717
 718
 719 H248_Transaction::operator const H248_TransactionReply &() const
 720 #endif
 721 {
 722 #ifndef PASN_LEANANDMEAN
 723   PAssert(PIsDescendant(PAssertNULL(choice), H248_TransactionReply), PInvalidCast);
 724 #endif
 725   return *(H248_TransactionReply *)choice;
 726 }
 727
 728
 729 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 730 H248_Transaction::operator H248_TransactionResponseAck &() const
 731 #else
 732 H248_Transaction::operator H248_TransactionResponseAck &()
 733 {
 734 #ifndef PASN_LEANANDMEAN
 735   PAssert(PIsDescendant(PAssertNULL(choice), H248_TransactionResponseAck), PInvalidCast);
 736 #endif
 737   return *(H248_TransactionResponseAck *)choice;
 738 }
 739
 740
 741 H248_Transaction::operator const H248_TransactionResponseAck &() const
 742 #endif
 743 {
 744 #ifndef PASN_LEANANDMEAN
 745   PAssert(PIsDescendant(PAssertNULL(choice), H248_TransactionResponseAck), PInvalidCast);
 746 #endif
 747   return *(H248_TransactionResponseAck *)choice;
 748 }
 749
 750
 751 BOOL H248_Transaction::CreateObject()
 752 {
 753   switch (tag) {
 754     case e_transactionRequest :
 755       choice = new H248_TransactionRequest();
 756       return TRUE;
 757     case e_transactionPending :
 758       choice = new H248_TransactionPending();
 759       return TRUE;
 760     case e_transactionReply :
 761       choice = new H248_TransactionReply();
 762       return TRUE;
 763     case e_transactionResponseAck :
 764       choice = new H248_TransactionResponseAck();
 765       return TRUE;
 766   }
 767
 768   choice = NULL;
 769   return FALSE;
 770 }
 771
 772
 773 PObject * H248_Transaction::Clone() const
 774 {
 775 #ifndef PASN_LEANANDMEAN
 776   PAssert(IsClass(H248_Transaction::Class()), PInvalidCast);
 777 #endif
 778   return new H248_Transaction(*this);
 779 }
 780
 781
 782 //
 783 // TransactionId
 784 //
 785
 786 H248_TransactionId::H248_TransactionId(unsigned tag, PASN_Object::TagClass tagClass)
 787   : PASN_Integer(tag, tagClass)
 788 {
 789   SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
 790 }
 791
 792
 793 H248_TransactionId & H248_TransactionId::operator=(int v)
 794 {
 795   SetValue(v);
 796   return *this;
 797 }
 798
 799
 800 H248_TransactionId & H248_TransactionId::operator=(unsigned v)
 801 {
 802   SetValue(v);
 803   return *this;
 804 }
 805
 806
 807 PObject * H248_TransactionId::Clone() const
 808 {
 809 #ifndef PASN_LEANANDMEAN
 810   PAssert(IsClass(H248_TransactionId::Class()), PInvalidCast);
 811 #endif
 812   return new H248_TransactionId(*this);
 813 }
 814
 815
 816 //
 817 // TransactionPending
 818 //
 819
 820 H248_TransactionPending::H248_TransactionPending(unsigned tag, PASN_Object::TagClass tagClass)
 821   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 822 {
 823 }
 824
 825
 826 #ifndef PASN_NOPRINTON
 827 void H248_TransactionPending::PrintOn(ostream & strm) const
 828 {
 829   int indent = strm.precision() + 2;
 830   strm << "{\n";
 831   strm << setw(indent+16) << "transactionId = " << setprecision(indent) << m_transactionId << '\n';
 832   strm << setw(indent-1) << setprecision(indent-2) << "}";
 833 }
 834 #endif
 835
 836
 837 PObject::Comparison H248_TransactionPending::Compare(const PObject & obj) const
 838 {
 839 #ifndef PASN_LEANANDMEAN
 840   PAssert(PIsDescendant(&obj, H248_TransactionPending), PInvalidCast);
 841 #endif
 842   const H248_TransactionPending & other = (const H248_TransactionPending &)obj;
 843
 844   Comparison result;
 845
 846   if ((result = m_transactionId.Compare(other.m_transactionId)) != EqualTo)
 847     return result;
 848
 849   return PASN_Sequence::Compare(other);
 850 }
 851
 852
 853 PINDEX H248_TransactionPending::GetDataLength() const
 854 {
 855   PINDEX length = 0;
 856   length += m_transactionId.GetObjectLength();
 857   return length;
 858 }
 859
 860
 861 BOOL H248_TransactionPending::Decode(PASN_Stream & strm)
 862 {
 863   if (!PreambleDecode(strm))
 864     return FALSE;
 865
 866   if (!m_transactionId.Decode(strm))
 867     return FALSE;
 868
 869   return UnknownExtensionsDecode(strm);
 870 }
 871
 872
 873 void H248_TransactionPending::Encode(PASN_Stream & strm) const
 874 {
 875   PreambleEncode(strm);
 876
 877   m_transactionId.Encode(strm);
 878
 879   UnknownExtensionsEncode(strm);
 880 }
 881
 882
 883 PObject * H248_TransactionPending::Clone() const
 884 {
 885 #ifndef PASN_LEANANDMEAN
 886   PAssert(IsClass(H248_TransactionPending::Class()), PInvalidCast);
 887 #endif
 888   return new H248_TransactionPending(*this);
 889 }
 890
 891
 892 //
 893 // TransactionResponseAck
 894 //
 895
 896 H248_TransactionResponseAck::H248_TransactionResponseAck(unsigned tag, PASN_Object::TagClass tagClass)
 897   : PASN_Array(tag, tagClass)
 898 {
 899 }
 900
 901
 902 PASN_Object * H248_TransactionResponseAck::CreateObject() const
 903 {
 904   return new H248_TransactionAck;
 905 }
 906
 907
 908 H248_TransactionAck & H248_TransactionResponseAck::operator[](PINDEX i) const
 909 {
 910   return (H248_TransactionAck &)array[i];
 911 }
 912
 913
 914 PObject * H248_TransactionResponseAck::Clone() const
 915 {
 916 #ifndef PASN_LEANANDMEAN
 917   PAssert(IsClass(H248_TransactionResponseAck::Class()), PInvalidCast);
 918 #endif
 919   return new H248_TransactionResponseAck(*this);
 920 }
 921
 922
 923 //
 924 // TransactionAck
 925 //
 926
 927 H248_TransactionAck::H248_TransactionAck(unsigned tag, PASN_Object::TagClass tagClass)
 928   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
 929 {
 930 }
 931
 932
 933 #ifndef PASN_NOPRINTON
 934 void H248_TransactionAck::PrintOn(ostream & strm) const
 935 {
 936   int indent = strm.precision() + 2;
 937   strm << "{\n";
 938   strm << setw(indent+11) << "firstAck = " << setprecision(indent) << m_firstAck << '\n';
 939   if (HasOptionalField(e_lastAck))
 940     strm << setw(indent+10) << "lastAck = " << setprecision(indent) << m_lastAck << '\n';
 941   strm << setw(indent-1) << setprecision(indent-2) << "}";
 942 }
 943 #endif
 944
 945
 946 PObject::Comparison H248_TransactionAck::Compare(const PObject & obj) const
 947 {
 948 #ifndef PASN_LEANANDMEAN
 949   PAssert(PIsDescendant(&obj, H248_TransactionAck), PInvalidCast);
 950 #endif
 951   const H248_TransactionAck & other = (const H248_TransactionAck &)obj;
 952
 953   Comparison result;
 954
 955   if ((result = m_firstAck.Compare(other.m_firstAck)) != EqualTo)
 956     return result;
 957   if ((result = m_lastAck.Compare(other.m_lastAck)) != EqualTo)
 958     return result;
 959
 960   return PASN_Sequence::Compare(other);
 961 }
 962
 963
 964 PINDEX H248_TransactionAck::GetDataLength() const
 965 {
 966   PINDEX length = 0;
 967   length += m_firstAck.GetObjectLength();
 968   if (HasOptionalField(e_lastAck))
 969     length += m_lastAck.GetObjectLength();
 970   return length;
 971 }
 972
 973
 974 BOOL H248_TransactionAck::Decode(PASN_Stream & strm)
 975 {
 976   if (!PreambleDecode(strm))
 977     return FALSE;
 978
 979   if (!m_firstAck.Decode(strm))
 980     return FALSE;
 981   if (HasOptionalField(e_lastAck) && !m_lastAck.Decode(strm))
 982     return FALSE;
 983
 984   return UnknownExtensionsDecode(strm);
 985 }
 986
 987
 988 void H248_TransactionAck::Encode(PASN_Stream & strm) const
 989 {
 990   PreambleEncode(strm);
 991
 992   m_firstAck.Encode(strm);
 993   if (HasOptionalField(e_lastAck))
 994     m_lastAck.Encode(strm);
 995
 996   UnknownExtensionsEncode(strm);
 997 }
 998
 999
1000 PObject * H248_TransactionAck::Clone() const
1001 {
1002 #ifndef PASN_LEANANDMEAN
1003   PAssert(IsClass(H248_TransactionAck::Class()), PInvalidCast);
1004 #endif
1005   return new H248_TransactionAck(*this);
1006 }
1007
1008
1009 //
1010 // ErrorCode
1011 //
1012
1013 H248_ErrorCode::H248_ErrorCode(unsigned tag, PASN_Object::TagClass tagClass)
1014   : PASN_Integer(tag, tagClass)
1015 {
1016   SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
1017 }
1018
1019
1020 H248_ErrorCode & H248_ErrorCode::operator=(int v)
1021 {
1022   SetValue(v);
1023   return *this;
1024 }
1025
1026
1027 H248_ErrorCode & H248_ErrorCode::operator=(unsigned v)
1028 {
1029   SetValue(v);
1030   return *this;
1031 }
1032
1033
1034 PObject * H248_ErrorCode::Clone() const
1035 {
1036 #ifndef PASN_LEANANDMEAN
1037   PAssert(IsClass(H248_ErrorCode::Class()), PInvalidCast);
1038 #endif
1039   return new H248_ErrorCode(*this);
1040 }
1041
1042
1043 //
1044 // ErrorText
1045 //
1046
1047 H248_ErrorText::H248_ErrorText(unsigned tag, PASN_Object::TagClass tagClass)
1048   : PASN_IA5String(tag, tagClass)
1049 {
1050 }
1051
1052
1053 H248_ErrorText & H248_ErrorText::operator=(const char * v)
1054 {
1055   SetValue(v);
1056   return *this;
1057 }
1058
1059
1060 H248_ErrorText & H248_ErrorText::operator=(const PString & v)
1061 {
1062   SetValue(v);
1063   return *this;
1064 }
1065
1066
1067 PObject * H248_ErrorText::Clone() const
1068 {
1069 #ifndef PASN_LEANANDMEAN
1070   PAssert(IsClass(H248_ErrorText::Class()), PInvalidCast);
1071 #endif
1072   return new H248_ErrorText(*this);
1073 }
1074
1075
1076 //
1077 // ContextID
1078 //
1079
1080 H248_ContextID::H248_ContextID(unsigned tag, PASN_Object::TagClass tagClass)
1081   : PASN_Integer(tag, tagClass)
1082 {
1083   SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
1084 }
1085
1086
1087 H248_ContextID & H248_ContextID::operator=(int v)
1088 {
1089   SetValue(v);
1090   return *this;
1091 }
1092
1093
1094 H248_ContextID & H248_ContextID::operator=(unsigned v)
1095 {
1096   SetValue(v);
1097   return *this;
1098 }
1099
1100
1101 PObject * H248_ContextID::Clone() const
1102 {
1103 #ifndef PASN_LEANANDMEAN
1104   PAssert(IsClass(H248_ContextID::Class()), PInvalidCast);
1105 #endif
1106   return new H248_ContextID(*this);
1107 }
1108
1109
1110 //
1111 // ContextAttrAuditRequest
1112 //
1113
1114 H248_ContextAttrAuditRequest::H248_ContextAttrAuditRequest(unsigned tag, PASN_Object::TagClass tagClass)
1115   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
1116 {
1117 }
1118
1119
1120 #ifndef PASN_NOPRINTON
1121 void H248_ContextAttrAuditRequest::PrintOn(ostream & strm) const
1122 {
1123   int indent = strm.precision() + 2;
1124   strm << "{\n";
1125   if (HasOptionalField(e_topology))
1126     strm << setw(indent+11) << "topology = " << setprecision(indent) << m_topology << '\n';
1127   if (HasOptionalField(e_emergency))
1128     strm << setw(indent+12) << "emergency = " << setprecision(indent) << m_emergency << '\n';
1129   if (HasOptionalField(e_priority))
1130     strm << setw(indent+11) << "priority = " << setprecision(indent) << m_priority << '\n';
1131   strm << setw(indent-1) << setprecision(indent-2) << "}";
1132 }
1133 #endif
1134
1135
1136 PObject::Comparison H248_ContextAttrAuditRequest::Compare(const PObject & obj) const
1137 {
1138 #ifndef PASN_LEANANDMEAN
1139   PAssert(PIsDescendant(&obj, H248_ContextAttrAuditRequest), PInvalidCast);
1140 #endif
1141   const H248_ContextAttrAuditRequest & other = (const H248_ContextAttrAuditRequest &)obj;
1142
1143   Comparison result;
1144
1145   if ((result = m_topology.Compare(other.m_topology)) != EqualTo)
1146     return result;
1147   if ((result = m_emergency.Compare(other.m_emergency)) != EqualTo)
1148     return result;
1149   if ((result = m_priority.Compare(other.m_priority)) != EqualTo)
1150     return result;
1151
1152   return PASN_Sequence::Compare(other);
1153 }
1154
1155
1156 PINDEX H248_ContextAttrAuditRequest::GetDataLength() const
1157 {
1158   PINDEX length = 0;
1159   if (HasOptionalField(e_topology))
1160     length += m_topology.GetObjectLength();
1161   if (HasOptionalField(e_emergency))
1162     length += m_emergency.GetObjectLength();
1163   if (HasOptionalField(e_priority))
1164     length += m_priority.GetObjectLength();
1165   return length;
1166 }
1167
1168
1169 BOOL H248_ContextAttrAuditRequest::Decode(PASN_Stream & strm)
1170 {
1171   if (!PreambleDecode(strm))
1172     return FALSE;
1173
1174   if (HasOptionalField(e_topology) && !m_topology.Decode(strm))
1175     return FALSE;
1176   if (HasOptionalField(e_emergency) && !m_emergency.Decode(strm))
1177     return FALSE;
1178   if (HasOptionalField(e_priority) && !m_priority.Decode(strm))
1179     return FALSE;
1180
1181   return UnknownExtensionsDecode(strm);
1182 }
1183
1184
1185 void H248_ContextAttrAuditRequest::Encode(PASN_Stream & strm) const
1186 {
1187   PreambleEncode(strm);
1188
1189   if (HasOptionalField(e_topology))
1190     m_topology.Encode(strm);
1191   if (HasOptionalField(e_emergency))
1192     m_emergency.Encode(strm);
1193   if (HasOptionalField(e_priority))
1194     m_priority.Encode(strm);
1195
1196   UnknownExtensionsEncode(strm);
1197 }
1198
1199
1200 PObject * H248_ContextAttrAuditRequest::Clone() const
1201 {
1202 #ifndef PASN_LEANANDMEAN
1203   PAssert(IsClass(H248_ContextAttrAuditRequest::Class()), PInvalidCast);
1204 #endif
1205   return new H248_ContextAttrAuditRequest(*this);
1206 }
1207
1208
1209
1210 #ifndef PASN_NOPRINTON
1211 const static PASN_Names Names_H248_Command[]={
1212       {"addReq",0}
1213      ,{"moveReq",1}
1214      ,{"modReq",2}
1215      ,{"subtractReq",3}
1216      ,{"auditCapRequest",4}
1217      ,{"auditValueRequest",5}
1218      ,{"notifyReq",6}
1219      ,{"serviceChangeReq",7}
1220 };
1221 #endif
1222 //
1223 // Command
1224 //
1225
1226 H248_Command::H248_Command(unsigned tag, PASN_Object::TagClass tagClass)
1227   : PASN_Choice(tag, tagClass, 8, TRUE
1228 #ifndef PASN_NOPRINTON
1229     ,(const PASN_Names *)Names_H248_Command,8
1230 #endif
1231 )
1232 {
1233 }
1234
1235
1236 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1237 H248_Command::operator H248_AmmRequest &() const
1238 #else
1239 H248_Command::operator H248_AmmRequest &()
1240 {
1241 #ifndef PASN_LEANANDMEAN
1242   PAssert(PIsDescendant(PAssertNULL(choice), H248_AmmRequest), PInvalidCast);
1243 #endif
1244   return *(H248_AmmRequest *)choice;
1245 }
1246
1247
1248 H248_Command::operator const H248_AmmRequest &() const
1249 #endif
1250 {
1251 #ifndef PASN_LEANANDMEAN
1252   PAssert(PIsDescendant(PAssertNULL(choice), H248_AmmRequest), PInvalidCast);
1253 #endif
1254   return *(H248_AmmRequest *)choice;
1255 }
1256
1257
1258 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1259 H248_Command::operator H248_SubtractRequest &() const
1260 #else
1261 H248_Command::operator H248_SubtractRequest &()
1262 {
1263 #ifndef PASN_LEANANDMEAN
1264   PAssert(PIsDescendant(PAssertNULL(choice), H248_SubtractRequest), PInvalidCast);
1265 #endif
1266   return *(H248_SubtractRequest *)choice;
1267 }
1268
1269
1270 H248_Command::operator const H248_SubtractRequest &() const
1271 #endif
1272 {
1273 #ifndef PASN_LEANANDMEAN
1274   PAssert(PIsDescendant(PAssertNULL(choice), H248_SubtractRequest), PInvalidCast);
1275 #endif
1276   return *(H248_SubtractRequest *)choice;
1277 }
1278
1279
1280 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1281 H248_Command::operator H248_AuditRequest &() const
1282 #else
1283 H248_Command::operator H248_AuditRequest &()
1284 {
1285 #ifndef PASN_LEANANDMEAN
1286   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditRequest), PInvalidCast);
1287 #endif
1288   return *(H248_AuditRequest *)choice;
1289 }
1290
1291
1292 H248_Command::operator const H248_AuditRequest &() const
1293 #endif
1294 {
1295 #ifndef PASN_LEANANDMEAN
1296   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditRequest), PInvalidCast);
1297 #endif
1298   return *(H248_AuditRequest *)choice;
1299 }
1300
1301
1302 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1303 H248_Command::operator H248_NotifyRequest &() const
1304 #else
1305 H248_Command::operator H248_NotifyRequest &()
1306 {
1307 #ifndef PASN_LEANANDMEAN
1308   PAssert(PIsDescendant(PAssertNULL(choice), H248_NotifyRequest), PInvalidCast);
1309 #endif
1310   return *(H248_NotifyRequest *)choice;
1311 }
1312
1313
1314 H248_Command::operator const H248_NotifyRequest &() const
1315 #endif
1316 {
1317 #ifndef PASN_LEANANDMEAN
1318   PAssert(PIsDescendant(PAssertNULL(choice), H248_NotifyRequest), PInvalidCast);
1319 #endif
1320   return *(H248_NotifyRequest *)choice;
1321 }
1322
1323
1324 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1325 H248_Command::operator H248_ServiceChangeRequest &() const
1326 #else
1327 H248_Command::operator H248_ServiceChangeRequest &()
1328 {
1329 #ifndef PASN_LEANANDMEAN
1330   PAssert(PIsDescendant(PAssertNULL(choice), H248_ServiceChangeRequest), PInvalidCast);
1331 #endif
1332   return *(H248_ServiceChangeRequest *)choice;
1333 }
1334
1335
1336 H248_Command::operator const H248_ServiceChangeRequest &() const
1337 #endif
1338 {
1339 #ifndef PASN_LEANANDMEAN
1340   PAssert(PIsDescendant(PAssertNULL(choice), H248_ServiceChangeRequest), PInvalidCast);
1341 #endif
1342   return *(H248_ServiceChangeRequest *)choice;
1343 }
1344
1345
1346 BOOL H248_Command::CreateObject()
1347 {
1348   switch (tag) {
1349     case e_addReq :
1350     case e_moveReq :
1351     case e_modReq :
1352       choice = new H248_AmmRequest();
1353       return TRUE;
1354     case e_subtractReq :
1355       choice = new H248_SubtractRequest();
1356       return TRUE;
1357     case e_auditCapRequest :
1358     case e_auditValueRequest :
1359       choice = new H248_AuditRequest();
1360       return TRUE;
1361     case e_notifyReq :
1362       choice = new H248_NotifyRequest();
1363       return TRUE;
1364     case e_serviceChangeReq :
1365       choice = new H248_ServiceChangeRequest();
1366       return TRUE;
1367   }
1368
1369   choice = NULL;
1370   return FALSE;
1371 }
1372
1373
1374 PObject * H248_Command::Clone() const
1375 {
1376 #ifndef PASN_LEANANDMEAN
1377   PAssert(IsClass(H248_Command::Class()), PInvalidCast);
1378 #endif
1379   return new H248_Command(*this);
1380 }
1381
1382
1383
1384 #ifndef PASN_NOPRINTON
1385 const static PASN_Names Names_H248_CommandReply[]={
1386       {"addReply",0}
1387      ,{"moveReply",1}
1388      ,{"modReply",2}
1389      ,{"subtractReply",3}
1390      ,{"auditCapReply",4}
1391      ,{"auditValueReply",5}
1392      ,{"notifyReply",6}
1393      ,{"serviceChangeReply",7}
1394 };
1395 #endif
1396 //
1397 // CommandReply
1398 //
1399
1400 H248_CommandReply::H248_CommandReply(unsigned tag, PASN_Object::TagClass tagClass)
1401   : PASN_Choice(tag, tagClass, 8, TRUE
1402 #ifndef PASN_NOPRINTON
1403     ,(const PASN_Names *)Names_H248_CommandReply,8
1404 #endif
1405 )
1406 {
1407 }
1408
1409
1410 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1411 H248_CommandReply::operator H248_AmmsReply &() const
1412 #else
1413 H248_CommandReply::operator H248_AmmsReply &()
1414 {
1415 #ifndef PASN_LEANANDMEAN
1416   PAssert(PIsDescendant(PAssertNULL(choice), H248_AmmsReply), PInvalidCast);
1417 #endif
1418   return *(H248_AmmsReply *)choice;
1419 }
1420
1421
1422 H248_CommandReply::operator const H248_AmmsReply &() const
1423 #endif
1424 {
1425 #ifndef PASN_LEANANDMEAN
1426   PAssert(PIsDescendant(PAssertNULL(choice), H248_AmmsReply), PInvalidCast);
1427 #endif
1428   return *(H248_AmmsReply *)choice;
1429 }
1430
1431
1432 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1433 H248_CommandReply::operator H248_AuditReply &() const
1434 #else
1435 H248_CommandReply::operator H248_AuditReply &()
1436 {
1437 #ifndef PASN_LEANANDMEAN
1438   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditReply), PInvalidCast);
1439 #endif
1440   return *(H248_AuditReply *)choice;
1441 }
1442
1443
1444 H248_CommandReply::operator const H248_AuditReply &() const
1445 #endif
1446 {
1447 #ifndef PASN_LEANANDMEAN
1448   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditReply), PInvalidCast);
1449 #endif
1450   return *(H248_AuditReply *)choice;
1451 }
1452
1453
1454 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1455 H248_CommandReply::operator H248_NotifyReply &() const
1456 #else
1457 H248_CommandReply::operator H248_NotifyReply &()
1458 {
1459 #ifndef PASN_LEANANDMEAN
1460   PAssert(PIsDescendant(PAssertNULL(choice), H248_NotifyReply), PInvalidCast);
1461 #endif
1462   return *(H248_NotifyReply *)choice;
1463 }
1464
1465
1466 H248_CommandReply::operator const H248_NotifyReply &() const
1467 #endif
1468 {
1469 #ifndef PASN_LEANANDMEAN
1470   PAssert(PIsDescendant(PAssertNULL(choice), H248_NotifyReply), PInvalidCast);
1471 #endif
1472   return *(H248_NotifyReply *)choice;
1473 }
1474
1475
1476 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1477 H248_CommandReply::operator H248_ServiceChangeReply &() const
1478 #else
1479 H248_CommandReply::operator H248_ServiceChangeReply &()
1480 {
1481 #ifndef PASN_LEANANDMEAN
1482   PAssert(PIsDescendant(PAssertNULL(choice), H248_ServiceChangeReply), PInvalidCast);
1483 #endif
1484   return *(H248_ServiceChangeReply *)choice;
1485 }
1486
1487
1488 H248_CommandReply::operator const H248_ServiceChangeReply &() const
1489 #endif
1490 {
1491 #ifndef PASN_LEANANDMEAN
1492   PAssert(PIsDescendant(PAssertNULL(choice), H248_ServiceChangeReply), PInvalidCast);
1493 #endif
1494   return *(H248_ServiceChangeReply *)choice;
1495 }
1496
1497
1498 BOOL H248_CommandReply::CreateObject()
1499 {
1500   switch (tag) {
1501     case e_addReply :
1502     case e_moveReply :
1503     case e_modReply :
1504     case e_subtractReply :
1505       choice = new H248_AmmsReply();
1506       return TRUE;
1507     case e_auditCapReply :
1508     case e_auditValueReply :
1509       choice = new H248_AuditReply();
1510       return TRUE;
1511     case e_notifyReply :
1512       choice = new H248_NotifyReply();
1513       return TRUE;
1514     case e_serviceChangeReply :
1515       choice = new H248_ServiceChangeReply();
1516       return TRUE;
1517   }
1518
1519   choice = NULL;
1520   return FALSE;
1521 }
1522
1523
1524 PObject * H248_CommandReply::Clone() const
1525 {
1526 #ifndef PASN_LEANANDMEAN
1527   PAssert(IsClass(H248_CommandReply::Class()), PInvalidCast);
1528 #endif
1529   return new H248_CommandReply(*this);
1530 }
1531
1532
1533
1534 #ifndef PASN_NOPRINTON
1535 const static PASN_Names Names_H248_AmmDescriptor[]={
1536       {"mediaDescriptor",0}
1537      ,{"modemDescriptor",1}
1538      ,{"muxDescriptor",2}
1539      ,{"eventsDescriptor",3}
1540      ,{"eventBufferDescriptor",4}
1541      ,{"signalsDescriptor",5}
1542      ,{"digitMapDescriptor",6}
1543      ,{"auditDescriptor",7}
1544 };
1545 #endif
1546 //
1547 // AmmDescriptor
1548 //
1549
1550 H248_AmmDescriptor::H248_AmmDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
1551   : PASN_Choice(tag, tagClass, 8, TRUE
1552 #ifndef PASN_NOPRINTON
1553     ,(const PASN_Names *)Names_H248_AmmDescriptor,8
1554 #endif
1555 )
1556 {
1557 }
1558
1559
1560 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1561 H248_AmmDescriptor::operator H248_MediaDescriptor &() const
1562 #else
1563 H248_AmmDescriptor::operator H248_MediaDescriptor &()
1564 {
1565 #ifndef PASN_LEANANDMEAN
1566   PAssert(PIsDescendant(PAssertNULL(choice), H248_MediaDescriptor), PInvalidCast);
1567 #endif
1568   return *(H248_MediaDescriptor *)choice;
1569 }
1570
1571
1572 H248_AmmDescriptor::operator const H248_MediaDescriptor &() const
1573 #endif
1574 {
1575 #ifndef PASN_LEANANDMEAN
1576   PAssert(PIsDescendant(PAssertNULL(choice), H248_MediaDescriptor), PInvalidCast);
1577 #endif
1578   return *(H248_MediaDescriptor *)choice;
1579 }
1580
1581
1582 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1583 H248_AmmDescriptor::operator H248_ModemDescriptor &() const
1584 #else
1585 H248_AmmDescriptor::operator H248_ModemDescriptor &()
1586 {
1587 #ifndef PASN_LEANANDMEAN
1588   PAssert(PIsDescendant(PAssertNULL(choice), H248_ModemDescriptor), PInvalidCast);
1589 #endif
1590   return *(H248_ModemDescriptor *)choice;
1591 }
1592
1593
1594 H248_AmmDescriptor::operator const H248_ModemDescriptor &() const
1595 #endif
1596 {
1597 #ifndef PASN_LEANANDMEAN
1598   PAssert(PIsDescendant(PAssertNULL(choice), H248_ModemDescriptor), PInvalidCast);
1599 #endif
1600   return *(H248_ModemDescriptor *)choice;
1601 }
1602
1603
1604 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1605 H248_AmmDescriptor::operator H248_MuxDescriptor &() const
1606 #else
1607 H248_AmmDescriptor::operator H248_MuxDescriptor &()
1608 {
1609 #ifndef PASN_LEANANDMEAN
1610   PAssert(PIsDescendant(PAssertNULL(choice), H248_MuxDescriptor), PInvalidCast);
1611 #endif
1612   return *(H248_MuxDescriptor *)choice;
1613 }
1614
1615
1616 H248_AmmDescriptor::operator const H248_MuxDescriptor &() const
1617 #endif
1618 {
1619 #ifndef PASN_LEANANDMEAN
1620   PAssert(PIsDescendant(PAssertNULL(choice), H248_MuxDescriptor), PInvalidCast);
1621 #endif
1622   return *(H248_MuxDescriptor *)choice;
1623 }
1624
1625
1626 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1627 H248_AmmDescriptor::operator H248_EventsDescriptor &() const
1628 #else
1629 H248_AmmDescriptor::operator H248_EventsDescriptor &()
1630 {
1631 #ifndef PASN_LEANANDMEAN
1632   PAssert(PIsDescendant(PAssertNULL(choice), H248_EventsDescriptor), PInvalidCast);
1633 #endif
1634   return *(H248_EventsDescriptor *)choice;
1635 }
1636
1637
1638 H248_AmmDescriptor::operator const H248_EventsDescriptor &() const
1639 #endif
1640 {
1641 #ifndef PASN_LEANANDMEAN
1642   PAssert(PIsDescendant(PAssertNULL(choice), H248_EventsDescriptor), PInvalidCast);
1643 #endif
1644   return *(H248_EventsDescriptor *)choice;
1645 }
1646
1647
1648 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1649 H248_AmmDescriptor::operator H248_EventBufferDescriptor &() const
1650 #else
1651 H248_AmmDescriptor::operator H248_EventBufferDescriptor &()
1652 {
1653 #ifndef PASN_LEANANDMEAN
1654   PAssert(PIsDescendant(PAssertNULL(choice), H248_EventBufferDescriptor), PInvalidCast);
1655 #endif
1656   return *(H248_EventBufferDescriptor *)choice;
1657 }
1658
1659
1660 H248_AmmDescriptor::operator const H248_EventBufferDescriptor &() const
1661 #endif
1662 {
1663 #ifndef PASN_LEANANDMEAN
1664   PAssert(PIsDescendant(PAssertNULL(choice), H248_EventBufferDescriptor), PInvalidCast);
1665 #endif
1666   return *(H248_EventBufferDescriptor *)choice;
1667 }
1668
1669
1670 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1671 H248_AmmDescriptor::operator H248_SignalsDescriptor &() const
1672 #else
1673 H248_AmmDescriptor::operator H248_SignalsDescriptor &()
1674 {
1675 #ifndef PASN_LEANANDMEAN
1676   PAssert(PIsDescendant(PAssertNULL(choice), H248_SignalsDescriptor), PInvalidCast);
1677 #endif
1678   return *(H248_SignalsDescriptor *)choice;
1679 }
1680
1681
1682 H248_AmmDescriptor::operator const H248_SignalsDescriptor &() const
1683 #endif
1684 {
1685 #ifndef PASN_LEANANDMEAN
1686   PAssert(PIsDescendant(PAssertNULL(choice), H248_SignalsDescriptor), PInvalidCast);
1687 #endif
1688   return *(H248_SignalsDescriptor *)choice;
1689 }
1690
1691
1692 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1693 H248_AmmDescriptor::operator H248_DigitMapDescriptor &() const
1694 #else
1695 H248_AmmDescriptor::operator H248_DigitMapDescriptor &()
1696 {
1697 #ifndef PASN_LEANANDMEAN
1698   PAssert(PIsDescendant(PAssertNULL(choice), H248_DigitMapDescriptor), PInvalidCast);
1699 #endif
1700   return *(H248_DigitMapDescriptor *)choice;
1701 }
1702
1703
1704 H248_AmmDescriptor::operator const H248_DigitMapDescriptor &() const
1705 #endif
1706 {
1707 #ifndef PASN_LEANANDMEAN
1708   PAssert(PIsDescendant(PAssertNULL(choice), H248_DigitMapDescriptor), PInvalidCast);
1709 #endif
1710   return *(H248_DigitMapDescriptor *)choice;
1711 }
1712
1713
1714 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1715 H248_AmmDescriptor::operator H248_AuditDescriptor &() const
1716 #else
1717 H248_AmmDescriptor::operator H248_AuditDescriptor &()
1718 {
1719 #ifndef PASN_LEANANDMEAN
1720   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditDescriptor), PInvalidCast);
1721 #endif
1722   return *(H248_AuditDescriptor *)choice;
1723 }
1724
1725
1726 H248_AmmDescriptor::operator const H248_AuditDescriptor &() const
1727 #endif
1728 {
1729 #ifndef PASN_LEANANDMEAN
1730   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditDescriptor), PInvalidCast);
1731 #endif
1732   return *(H248_AuditDescriptor *)choice;
1733 }
1734
1735
1736 BOOL H248_AmmDescriptor::CreateObject()
1737 {
1738   switch (tag) {
1739     case e_mediaDescriptor :
1740       choice = new H248_MediaDescriptor();
1741       return TRUE;
1742     case e_modemDescriptor :
1743       choice = new H248_ModemDescriptor();
1744       return TRUE;
1745     case e_muxDescriptor :
1746       choice = new H248_MuxDescriptor();
1747       return TRUE;
1748     case e_eventsDescriptor :
1749       choice = new H248_EventsDescriptor();
1750       return TRUE;
1751     case e_eventBufferDescriptor :
1752       choice = new H248_EventBufferDescriptor();
1753       return TRUE;
1754     case e_signalsDescriptor :
1755       choice = new H248_SignalsDescriptor();
1756       return TRUE;
1757     case e_digitMapDescriptor :
1758       choice = new H248_DigitMapDescriptor();
1759       return TRUE;
1760     case e_auditDescriptor :
1761       choice = new H248_AuditDescriptor();
1762       return TRUE;
1763   }
1764
1765   choice = NULL;
1766   return FALSE;
1767 }
1768
1769
1770 PObject * H248_AmmDescriptor::Clone() const
1771 {
1772 #ifndef PASN_LEANANDMEAN
1773   PAssert(IsClass(H248_AmmDescriptor::Class()), PInvalidCast);
1774 #endif
1775   return new H248_AmmDescriptor(*this);
1776 }
1777
1778
1779
1780 #ifndef PASN_NOPRINTON
1781 const static PASN_Names Names_H248_AuditReply[]={
1782       {"contextAuditResult",0}
1783      ,{"error",1}
1784      ,{"auditResult",2}
1785 };
1786 #endif
1787 //
1788 // AuditReply
1789 //
1790
1791 H248_AuditReply::H248_AuditReply(unsigned tag, PASN_Object::TagClass tagClass)
1792   : PASN_Choice(tag, tagClass, 3, TRUE
1793 #ifndef PASN_NOPRINTON
1794     ,(const PASN_Names *)Names_H248_AuditReply,3
1795 #endif
1796 )
1797 {
1798 }
1799
1800
1801 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1802 H248_AuditReply::operator H248_TerminationIDList &() const
1803 #else
1804 H248_AuditReply::operator H248_TerminationIDList &()
1805 {
1806 #ifndef PASN_LEANANDMEAN
1807   PAssert(PIsDescendant(PAssertNULL(choice), H248_TerminationIDList), PInvalidCast);
1808 #endif
1809   return *(H248_TerminationIDList *)choice;
1810 }
1811
1812
1813 H248_AuditReply::operator const H248_TerminationIDList &() const
1814 #endif
1815 {
1816 #ifndef PASN_LEANANDMEAN
1817   PAssert(PIsDescendant(PAssertNULL(choice), H248_TerminationIDList), PInvalidCast);
1818 #endif
1819   return *(H248_TerminationIDList *)choice;
1820 }
1821
1822
1823 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1824 H248_AuditReply::operator H248_ErrorDescriptor &() const
1825 #else
1826 H248_AuditReply::operator H248_ErrorDescriptor &()
1827 {
1828 #ifndef PASN_LEANANDMEAN
1829   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
1830 #endif
1831   return *(H248_ErrorDescriptor *)choice;
1832 }
1833
1834
1835 H248_AuditReply::operator const H248_ErrorDescriptor &() const
1836 #endif
1837 {
1838 #ifndef PASN_LEANANDMEAN
1839   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
1840 #endif
1841   return *(H248_ErrorDescriptor *)choice;
1842 }
1843
1844
1845 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1846 H248_AuditReply::operator H248_AuditResult &() const
1847 #else
1848 H248_AuditReply::operator H248_AuditResult &()
1849 {
1850 #ifndef PASN_LEANANDMEAN
1851   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditResult), PInvalidCast);
1852 #endif
1853   return *(H248_AuditResult *)choice;
1854 }
1855
1856
1857 H248_AuditReply::operator const H248_AuditResult &() const
1858 #endif
1859 {
1860 #ifndef PASN_LEANANDMEAN
1861   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditResult), PInvalidCast);
1862 #endif
1863   return *(H248_AuditResult *)choice;
1864 }
1865
1866
1867 BOOL H248_AuditReply::CreateObject()
1868 {
1869   switch (tag) {
1870     case e_contextAuditResult :
1871       choice = new H248_TerminationIDList();
1872       return TRUE;
1873     case e_error :
1874       choice = new H248_ErrorDescriptor();
1875       return TRUE;
1876     case e_auditResult :
1877       choice = new H248_AuditResult();
1878       return TRUE;
1879   }
1880
1881   choice = NULL;
1882   return FALSE;
1883 }
1884
1885
1886 PObject * H248_AuditReply::Clone() const
1887 {
1888 #ifndef PASN_LEANANDMEAN
1889   PAssert(IsClass(H248_AuditReply::Class()), PInvalidCast);
1890 #endif
1891   return new H248_AuditReply(*this);
1892 }
1893
1894
1895 //
1896 // TerminationAudit
1897 //
1898
1899 H248_TerminationAudit::H248_TerminationAudit(unsigned tag, PASN_Object::TagClass tagClass)
1900   : PASN_Array(tag, tagClass)
1901 {
1902 }
1903
1904
1905 PASN_Object * H248_TerminationAudit::CreateObject() const
1906 {
1907   return new H248_AuditReturnParameter;
1908 }
1909
1910
1911 H248_AuditReturnParameter & H248_TerminationAudit::operator[](PINDEX i) const
1912 {
1913   return (H248_AuditReturnParameter &)array[i];
1914 }
1915
1916
1917 PObject * H248_TerminationAudit::Clone() const
1918 {
1919 #ifndef PASN_LEANANDMEAN
1920   PAssert(IsClass(H248_TerminationAudit::Class()), PInvalidCast);
1921 #endif
1922   return new H248_TerminationAudit(*this);
1923 }
1924
1925
1926
1927 #ifndef PASN_NOPRINTON
1928 const static PASN_Names Names_H248_AuditReturnParameter[]={
1929       {"errorDescriptor",0}
1930      ,{"mediaDescriptor",1}
1931      ,{"modemDescriptor",2}
1932      ,{"muxDescriptor",3}
1933      ,{"eventsDescriptor",4}
1934      ,{"eventBufferDescriptor",5}
1935      ,{"signalsDescriptor",6}
1936      ,{"digitMapDescriptor",7}
1937      ,{"observedEventsDescriptor",8}
1938      ,{"statisticsDescriptor",9}
1939      ,{"packagesDescriptor",10}
1940      ,{"emptyDescriptors",11}
1941 };
1942 #endif
1943 //
1944 // AuditReturnParameter
1945 //
1946
1947 H248_AuditReturnParameter::H248_AuditReturnParameter(unsigned tag, PASN_Object::TagClass tagClass)
1948   : PASN_Choice(tag, tagClass, 12, TRUE
1949 #ifndef PASN_NOPRINTON
1950     ,(const PASN_Names *)Names_H248_AuditReturnParameter,12
1951 #endif
1952 )
1953 {
1954 }
1955
1956
1957 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1958 H248_AuditReturnParameter::operator H248_ErrorDescriptor &() const
1959 #else
1960 H248_AuditReturnParameter::operator H248_ErrorDescriptor &()
1961 {
1962 #ifndef PASN_LEANANDMEAN
1963   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
1964 #endif
1965   return *(H248_ErrorDescriptor *)choice;
1966 }
1967
1968
1969 H248_AuditReturnParameter::operator const H248_ErrorDescriptor &() const
1970 #endif
1971 {
1972 #ifndef PASN_LEANANDMEAN
1973   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
1974 #endif
1975   return *(H248_ErrorDescriptor *)choice;
1976 }
1977
1978
1979 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1980 H248_AuditReturnParameter::operator H248_MediaDescriptor &() const
1981 #else
1982 H248_AuditReturnParameter::operator H248_MediaDescriptor &()
1983 {
1984 #ifndef PASN_LEANANDMEAN
1985   PAssert(PIsDescendant(PAssertNULL(choice), H248_MediaDescriptor), PInvalidCast);
1986 #endif
1987   return *(H248_MediaDescriptor *)choice;
1988 }
1989
1990
1991 H248_AuditReturnParameter::operator const H248_MediaDescriptor &() const
1992 #endif
1993 {
1994 #ifndef PASN_LEANANDMEAN
1995   PAssert(PIsDescendant(PAssertNULL(choice), H248_MediaDescriptor), PInvalidCast);
1996 #endif
1997   return *(H248_MediaDescriptor *)choice;
1998 }
1999
2000
2001 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2002 H248_AuditReturnParameter::operator H248_ModemDescriptor &() const
2003 #else
2004 H248_AuditReturnParameter::operator H248_ModemDescriptor &()
2005 {
2006 #ifndef PASN_LEANANDMEAN
2007   PAssert(PIsDescendant(PAssertNULL(choice), H248_ModemDescriptor), PInvalidCast);
2008 #endif
2009   return *(H248_ModemDescriptor *)choice;
2010 }
2011
2012
2013 H248_AuditReturnParameter::operator const H248_ModemDescriptor &() const
2014 #endif
2015 {
2016 #ifndef PASN_LEANANDMEAN
2017   PAssert(PIsDescendant(PAssertNULL(choice), H248_ModemDescriptor), PInvalidCast);
2018 #endif
2019   return *(H248_ModemDescriptor *)choice;
2020 }
2021
2022
2023 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2024 H248_AuditReturnParameter::operator H248_MuxDescriptor &() const
2025 #else
2026 H248_AuditReturnParameter::operator H248_MuxDescriptor &()
2027 {
2028 #ifndef PASN_LEANANDMEAN
2029   PAssert(PIsDescendant(PAssertNULL(choice), H248_MuxDescriptor), PInvalidCast);
2030 #endif
2031   return *(H248_MuxDescriptor *)choice;
2032 }
2033
2034
2035 H248_AuditReturnParameter::operator const H248_MuxDescriptor &() const
2036 #endif
2037 {
2038 #ifndef PASN_LEANANDMEAN
2039   PAssert(PIsDescendant(PAssertNULL(choice), H248_MuxDescriptor), PInvalidCast);
2040 #endif
2041   return *(H248_MuxDescriptor *)choice;
2042 }
2043
2044
2045 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2046 H248_AuditReturnParameter::operator H248_EventsDescriptor &() const
2047 #else
2048 H248_AuditReturnParameter::operator H248_EventsDescriptor &()
2049 {
2050 #ifndef PASN_LEANANDMEAN
2051   PAssert(PIsDescendant(PAssertNULL(choice), H248_EventsDescriptor), PInvalidCast);
2052 #endif
2053   return *(H248_EventsDescriptor *)choice;
2054 }
2055
2056
2057 H248_AuditReturnParameter::operator const H248_EventsDescriptor &() const
2058 #endif
2059 {
2060 #ifndef PASN_LEANANDMEAN
2061   PAssert(PIsDescendant(PAssertNULL(choice), H248_EventsDescriptor), PInvalidCast);
2062 #endif
2063   return *(H248_EventsDescriptor *)choice;
2064 }
2065
2066
2067 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2068 H248_AuditReturnParameter::operator H248_EventBufferDescriptor &() const
2069 #else
2070 H248_AuditReturnParameter::operator H248_EventBufferDescriptor &()
2071 {
2072 #ifndef PASN_LEANANDMEAN
2073   PAssert(PIsDescendant(PAssertNULL(choice), H248_EventBufferDescriptor), PInvalidCast);
2074 #endif
2075   return *(H248_EventBufferDescriptor *)choice;
2076 }
2077
2078
2079 H248_AuditReturnParameter::operator const H248_EventBufferDescriptor &() const
2080 #endif
2081 {
2082 #ifndef PASN_LEANANDMEAN
2083   PAssert(PIsDescendant(PAssertNULL(choice), H248_EventBufferDescriptor), PInvalidCast);
2084 #endif
2085   return *(H248_EventBufferDescriptor *)choice;
2086 }
2087
2088
2089 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2090 H248_AuditReturnParameter::operator H248_SignalsDescriptor &() const
2091 #else
2092 H248_AuditReturnParameter::operator H248_SignalsDescriptor &()
2093 {
2094 #ifndef PASN_LEANANDMEAN
2095   PAssert(PIsDescendant(PAssertNULL(choice), H248_SignalsDescriptor), PInvalidCast);
2096 #endif
2097   return *(H248_SignalsDescriptor *)choice;
2098 }
2099
2100
2101 H248_AuditReturnParameter::operator const H248_SignalsDescriptor &() const
2102 #endif
2103 {
2104 #ifndef PASN_LEANANDMEAN
2105   PAssert(PIsDescendant(PAssertNULL(choice), H248_SignalsDescriptor), PInvalidCast);
2106 #endif
2107   return *(H248_SignalsDescriptor *)choice;
2108 }
2109
2110
2111 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2112 H248_AuditReturnParameter::operator H248_DigitMapDescriptor &() const
2113 #else
2114 H248_AuditReturnParameter::operator H248_DigitMapDescriptor &()
2115 {
2116 #ifndef PASN_LEANANDMEAN
2117   PAssert(PIsDescendant(PAssertNULL(choice), H248_DigitMapDescriptor), PInvalidCast);
2118 #endif
2119   return *(H248_DigitMapDescriptor *)choice;
2120 }
2121
2122
2123 H248_AuditReturnParameter::operator const H248_DigitMapDescriptor &() const
2124 #endif
2125 {
2126 #ifndef PASN_LEANANDMEAN
2127   PAssert(PIsDescendant(PAssertNULL(choice), H248_DigitMapDescriptor), PInvalidCast);
2128 #endif
2129   return *(H248_DigitMapDescriptor *)choice;
2130 }
2131
2132
2133 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2134 H248_AuditReturnParameter::operator H248_ObservedEventsDescriptor &() const
2135 #else
2136 H248_AuditReturnParameter::operator H248_ObservedEventsDescriptor &()
2137 {
2138 #ifndef PASN_LEANANDMEAN
2139   PAssert(PIsDescendant(PAssertNULL(choice), H248_ObservedEventsDescriptor), PInvalidCast);
2140 #endif
2141   return *(H248_ObservedEventsDescriptor *)choice;
2142 }
2143
2144
2145 H248_AuditReturnParameter::operator const H248_ObservedEventsDescriptor &() const
2146 #endif
2147 {
2148 #ifndef PASN_LEANANDMEAN
2149   PAssert(PIsDescendant(PAssertNULL(choice), H248_ObservedEventsDescriptor), PInvalidCast);
2150 #endif
2151   return *(H248_ObservedEventsDescriptor *)choice;
2152 }
2153
2154
2155 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2156 H248_AuditReturnParameter::operator H248_StatisticsDescriptor &() const
2157 #else
2158 H248_AuditReturnParameter::operator H248_StatisticsDescriptor &()
2159 {
2160 #ifndef PASN_LEANANDMEAN
2161   PAssert(PIsDescendant(PAssertNULL(choice), H248_StatisticsDescriptor), PInvalidCast);
2162 #endif
2163   return *(H248_StatisticsDescriptor *)choice;
2164 }
2165
2166
2167 H248_AuditReturnParameter::operator const H248_StatisticsDescriptor &() const
2168 #endif
2169 {
2170 #ifndef PASN_LEANANDMEAN
2171   PAssert(PIsDescendant(PAssertNULL(choice), H248_StatisticsDescriptor), PInvalidCast);
2172 #endif
2173   return *(H248_StatisticsDescriptor *)choice;
2174 }
2175
2176
2177 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2178 H248_AuditReturnParameter::operator H248_PackagesDescriptor &() const
2179 #else
2180 H248_AuditReturnParameter::operator H248_PackagesDescriptor &()
2181 {
2182 #ifndef PASN_LEANANDMEAN
2183   PAssert(PIsDescendant(PAssertNULL(choice), H248_PackagesDescriptor), PInvalidCast);
2184 #endif
2185   return *(H248_PackagesDescriptor *)choice;
2186 }
2187
2188
2189 H248_AuditReturnParameter::operator const H248_PackagesDescriptor &() const
2190 #endif
2191 {
2192 #ifndef PASN_LEANANDMEAN
2193   PAssert(PIsDescendant(PAssertNULL(choice), H248_PackagesDescriptor), PInvalidCast);
2194 #endif
2195   return *(H248_PackagesDescriptor *)choice;
2196 }
2197
2198
2199 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2200 H248_AuditReturnParameter::operator H248_AuditDescriptor &() const
2201 #else
2202 H248_AuditReturnParameter::operator H248_AuditDescriptor &()
2203 {
2204 #ifndef PASN_LEANANDMEAN
2205   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditDescriptor), PInvalidCast);
2206 #endif
2207   return *(H248_AuditDescriptor *)choice;
2208 }
2209
2210
2211 H248_AuditReturnParameter::operator const H248_AuditDescriptor &() const
2212 #endif
2213 {
2214 #ifndef PASN_LEANANDMEAN
2215   PAssert(PIsDescendant(PAssertNULL(choice), H248_AuditDescriptor), PInvalidCast);
2216 #endif
2217   return *(H248_AuditDescriptor *)choice;
2218 }
2219
2220
2221 BOOL H248_AuditReturnParameter::CreateObject()
2222 {
2223   switch (tag) {
2224     case e_errorDescriptor :
2225       choice = new H248_ErrorDescriptor();
2226       return TRUE;
2227     case e_mediaDescriptor :
2228       choice = new H248_MediaDescriptor();
2229       return TRUE;
2230     case e_modemDescriptor :
2231       choice = new H248_ModemDescriptor();
2232       return TRUE;
2233     case e_muxDescriptor :
2234       choice = new H248_MuxDescriptor();
2235       return TRUE;
2236     case e_eventsDescriptor :
2237       choice = new H248_EventsDescriptor();
2238       return TRUE;
2239     case e_eventBufferDescriptor :
2240       choice = new H248_EventBufferDescriptor();
2241       return TRUE;
2242     case e_signalsDescriptor :
2243       choice = new H248_SignalsDescriptor();
2244       return TRUE;
2245     case e_digitMapDescriptor :
2246       choice = new H248_DigitMapDescriptor();
2247       return TRUE;
2248     case e_observedEventsDescriptor :
2249       choice = new H248_ObservedEventsDescriptor();
2250       return TRUE;
2251     case e_statisticsDescriptor :
2252       choice = new H248_StatisticsDescriptor();
2253       return TRUE;
2254     case e_packagesDescriptor :
2255       choice = new H248_PackagesDescriptor();
2256       return TRUE;
2257     case e_emptyDescriptors :
2258       choice = new H248_AuditDescriptor();
2259       return TRUE;
2260   }
2261
2262   choice = NULL;
2263   return FALSE;
2264 }
2265
2266
2267 PObject * H248_AuditReturnParameter::Clone() const
2268 {
2269 #ifndef PASN_LEANANDMEAN
2270   PAssert(IsClass(H248_AuditReturnParameter::Class()), PInvalidCast);
2271 #endif
2272   return new H248_AuditReturnParameter(*this);
2273 }
2274
2275
2276
2277 #ifndef PASN_NOPRINTON
2278 const static PASN_Names Names_H248_IndAuditParameter[]={
2279       {"indaudmediaDescriptor",0}
2280      ,{"indaudeventsDescriptor",1}
2281      ,{"indaudeventBufferDescriptor",2}
2282      ,{"indaudsignalsDescriptor",3}
2283      ,{"indauddigitMapDescriptor",4}
2284      ,{"indaudstatisticsDescriptor",5}
2285      ,{"indaudpackagesDescriptor",6}
2286 };
2287 #endif
2288 //
2289 // IndAuditParameter
2290 //
2291
2292 H248_IndAuditParameter::H248_IndAuditParameter(unsigned tag, PASN_Object::TagClass tagClass)
2293   : PASN_Choice(tag, tagClass, 7, TRUE
2294 #ifndef PASN_NOPRINTON
2295     ,(const PASN_Names *)Names_H248_IndAuditParameter,7
2296 #endif
2297 )
2298 {
2299 }
2300
2301
2302 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2303 H248_IndAuditParameter::operator H248_IndAudMediaDescriptor &() const
2304 #else
2305 H248_IndAuditParameter::operator H248_IndAudMediaDescriptor &()
2306 {
2307 #ifndef PASN_LEANANDMEAN
2308   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudMediaDescriptor), PInvalidCast);
2309 #endif
2310   return *(H248_IndAudMediaDescriptor *)choice;
2311 }
2312
2313
2314 H248_IndAuditParameter::operator const H248_IndAudMediaDescriptor &() const
2315 #endif
2316 {
2317 #ifndef PASN_LEANANDMEAN
2318   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudMediaDescriptor), PInvalidCast);
2319 #endif
2320   return *(H248_IndAudMediaDescriptor *)choice;
2321 }
2322
2323
2324 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2325 H248_IndAuditParameter::operator H248_IndAudEventsDescriptor &() const
2326 #else
2327 H248_IndAuditParameter::operator H248_IndAudEventsDescriptor &()
2328 {
2329 #ifndef PASN_LEANANDMEAN
2330   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudEventsDescriptor), PInvalidCast);
2331 #endif
2332   return *(H248_IndAudEventsDescriptor *)choice;
2333 }
2334
2335
2336 H248_IndAuditParameter::operator const H248_IndAudEventsDescriptor &() const
2337 #endif
2338 {
2339 #ifndef PASN_LEANANDMEAN
2340   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudEventsDescriptor), PInvalidCast);
2341 #endif
2342   return *(H248_IndAudEventsDescriptor *)choice;
2343 }
2344
2345
2346 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2347 H248_IndAuditParameter::operator H248_IndAudEventBufferDescriptor &() const
2348 #else
2349 H248_IndAuditParameter::operator H248_IndAudEventBufferDescriptor &()
2350 {
2351 #ifndef PASN_LEANANDMEAN
2352   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudEventBufferDescriptor), PInvalidCast);
2353 #endif
2354   return *(H248_IndAudEventBufferDescriptor *)choice;
2355 }
2356
2357
2358 H248_IndAuditParameter::operator const H248_IndAudEventBufferDescriptor &() const
2359 #endif
2360 {
2361 #ifndef PASN_LEANANDMEAN
2362   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudEventBufferDescriptor), PInvalidCast);
2363 #endif
2364   return *(H248_IndAudEventBufferDescriptor *)choice;
2365 }
2366
2367
2368 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2369 H248_IndAuditParameter::operator H248_IndAudSignalsDescriptor &() const
2370 #else
2371 H248_IndAuditParameter::operator H248_IndAudSignalsDescriptor &()
2372 {
2373 #ifndef PASN_LEANANDMEAN
2374   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudSignalsDescriptor), PInvalidCast);
2375 #endif
2376   return *(H248_IndAudSignalsDescriptor *)choice;
2377 }
2378
2379
2380 H248_IndAuditParameter::operator const H248_IndAudSignalsDescriptor &() const
2381 #endif
2382 {
2383 #ifndef PASN_LEANANDMEAN
2384   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudSignalsDescriptor), PInvalidCast);
2385 #endif
2386   return *(H248_IndAudSignalsDescriptor *)choice;
2387 }
2388
2389
2390 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2391 H248_IndAuditParameter::operator H248_IndAudDigitMapDescriptor &() const
2392 #else
2393 H248_IndAuditParameter::operator H248_IndAudDigitMapDescriptor &()
2394 {
2395 #ifndef PASN_LEANANDMEAN
2396   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudDigitMapDescriptor), PInvalidCast);
2397 #endif
2398   return *(H248_IndAudDigitMapDescriptor *)choice;
2399 }
2400
2401
2402 H248_IndAuditParameter::operator const H248_IndAudDigitMapDescriptor &() const
2403 #endif
2404 {
2405 #ifndef PASN_LEANANDMEAN
2406   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudDigitMapDescriptor), PInvalidCast);
2407 #endif
2408   return *(H248_IndAudDigitMapDescriptor *)choice;
2409 }
2410
2411
2412 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2413 H248_IndAuditParameter::operator H248_IndAudStatisticsDescriptor &() const
2414 #else
2415 H248_IndAuditParameter::operator H248_IndAudStatisticsDescriptor &()
2416 {
2417 #ifndef PASN_LEANANDMEAN
2418   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudStatisticsDescriptor), PInvalidCast);
2419 #endif
2420   return *(H248_IndAudStatisticsDescriptor *)choice;
2421 }
2422
2423
2424 H248_IndAuditParameter::operator const H248_IndAudStatisticsDescriptor &() const
2425 #endif
2426 {
2427 #ifndef PASN_LEANANDMEAN
2428   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudStatisticsDescriptor), PInvalidCast);
2429 #endif
2430   return *(H248_IndAudStatisticsDescriptor *)choice;
2431 }
2432
2433
2434 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2435 H248_IndAuditParameter::operator H248_IndAudPackagesDescriptor &() const
2436 #else
2437 H248_IndAuditParameter::operator H248_IndAudPackagesDescriptor &()
2438 {
2439 #ifndef PASN_LEANANDMEAN
2440   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudPackagesDescriptor), PInvalidCast);
2441 #endif
2442   return *(H248_IndAudPackagesDescriptor *)choice;
2443 }
2444
2445
2446 H248_IndAuditParameter::operator const H248_IndAudPackagesDescriptor &() const
2447 #endif
2448 {
2449 #ifndef PASN_LEANANDMEAN
2450   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudPackagesDescriptor), PInvalidCast);
2451 #endif
2452   return *(H248_IndAudPackagesDescriptor *)choice;
2453 }
2454
2455
2456 BOOL H248_IndAuditParameter::CreateObject()
2457 {
2458   switch (tag) {
2459     case e_indaudmediaDescriptor :
2460       choice = new H248_IndAudMediaDescriptor();
2461       return TRUE;
2462     case e_indaudeventsDescriptor :
2463       choice = new H248_IndAudEventsDescriptor();
2464       return TRUE;
2465     case e_indaudeventBufferDescriptor :
2466       choice = new H248_IndAudEventBufferDescriptor();
2467       return TRUE;
2468     case e_indaudsignalsDescriptor :
2469       choice = new H248_IndAudSignalsDescriptor();
2470       return TRUE;
2471     case e_indauddigitMapDescriptor :
2472       choice = new H248_IndAudDigitMapDescriptor();
2473       return TRUE;
2474     case e_indaudstatisticsDescriptor :
2475       choice = new H248_IndAudStatisticsDescriptor();
2476       return TRUE;
2477     case e_indaudpackagesDescriptor :
2478       choice = new H248_IndAudPackagesDescriptor();
2479       return TRUE;
2480   }
2481
2482   choice = NULL;
2483   return FALSE;
2484 }
2485
2486
2487 PObject * H248_IndAuditParameter::Clone() const
2488 {
2489 #ifndef PASN_LEANANDMEAN
2490   PAssert(IsClass(H248_IndAuditParameter::Class()), PInvalidCast);
2491 #endif
2492   return new H248_IndAuditParameter(*this);
2493 }
2494
2495
2496 //
2497 // IndAudPropertyGroup
2498 //
2499
2500 H248_IndAudPropertyGroup::H248_IndAudPropertyGroup(unsigned tag, PASN_Object::TagClass tagClass)
2501   : PASN_Array(tag, tagClass)
2502 {
2503 }
2504
2505
2506 PASN_Object * H248_IndAudPropertyGroup::CreateObject() const
2507 {
2508   return new H248_IndAudPropertyParm;
2509 }
2510
2511
2512 H248_IndAudPropertyParm & H248_IndAudPropertyGroup::operator[](PINDEX i) const
2513 {
2514   return (H248_IndAudPropertyParm &)array[i];
2515 }
2516
2517
2518 PObject * H248_IndAudPropertyGroup::Clone() const
2519 {
2520 #ifndef PASN_LEANANDMEAN
2521   PAssert(IsClass(H248_IndAudPropertyGroup::Class()), PInvalidCast);
2522 #endif
2523   return new H248_IndAudPropertyGroup(*this);
2524 }
2525
2526
2527
2528 #ifndef PASN_NOPRINTON
2529 const static PASN_Names Names_H248_IndAudSignalsDescriptor[]={
2530       {"signal",0}
2531      ,{"seqSigList",1}
2532 };
2533 #endif
2534 //
2535 // IndAudSignalsDescriptor
2536 //
2537
2538 H248_IndAudSignalsDescriptor::H248_IndAudSignalsDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
2539   : PASN_Choice(tag, tagClass, 2, TRUE
2540 #ifndef PASN_NOPRINTON
2541     ,(const PASN_Names *)Names_H248_IndAudSignalsDescriptor,2
2542 #endif
2543 )
2544 {
2545 }
2546
2547
2548 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2549 H248_IndAudSignalsDescriptor::operator H248_IndAudSignal &() const
2550 #else
2551 H248_IndAudSignalsDescriptor::operator H248_IndAudSignal &()
2552 {
2553 #ifndef PASN_LEANANDMEAN
2554   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudSignal), PInvalidCast);
2555 #endif
2556   return *(H248_IndAudSignal *)choice;
2557 }
2558
2559
2560 H248_IndAudSignalsDescriptor::operator const H248_IndAudSignal &() const
2561 #endif
2562 {
2563 #ifndef PASN_LEANANDMEAN
2564   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudSignal), PInvalidCast);
2565 #endif
2566   return *(H248_IndAudSignal *)choice;
2567 }
2568
2569
2570 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2571 H248_IndAudSignalsDescriptor::operator H248_IndAudSeqSigList &() const
2572 #else
2573 H248_IndAudSignalsDescriptor::operator H248_IndAudSeqSigList &()
2574 {
2575 #ifndef PASN_LEANANDMEAN
2576   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudSeqSigList), PInvalidCast);
2577 #endif
2578   return *(H248_IndAudSeqSigList *)choice;
2579 }
2580
2581
2582 H248_IndAudSignalsDescriptor::operator const H248_IndAudSeqSigList &() const
2583 #endif
2584 {
2585 #ifndef PASN_LEANANDMEAN
2586   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudSeqSigList), PInvalidCast);
2587 #endif
2588   return *(H248_IndAudSeqSigList *)choice;
2589 }
2590
2591
2592 BOOL H248_IndAudSignalsDescriptor::CreateObject()
2593 {
2594   switch (tag) {
2595     case e_signal :
2596       choice = new H248_IndAudSignal();
2597       return TRUE;
2598     case e_seqSigList :
2599       choice = new H248_IndAudSeqSigList();
2600       return TRUE;
2601   }
2602
2603   choice = NULL;
2604   return FALSE;
2605 }
2606
2607
2608 PObject * H248_IndAudSignalsDescriptor::Clone() const
2609 {
2610 #ifndef PASN_LEANANDMEAN
2611   PAssert(IsClass(H248_IndAudSignalsDescriptor::Class()), PInvalidCast);
2612 #endif
2613   return new H248_IndAudSignalsDescriptor(*this);
2614 }
2615
2616
2617
2618 #ifndef PASN_NOPRINTON
2619 const static PASN_Names Names_H248_ServiceChangeResult[]={
2620       {"errorDescriptor",0}
2621      ,{"serviceChangeResParms",1}
2622 };
2623 #endif
2624 //
2625 // ServiceChangeResult
2626 //
2627
2628 H248_ServiceChangeResult::H248_ServiceChangeResult(unsigned tag, PASN_Object::TagClass tagClass)
2629   : PASN_Choice(tag, tagClass, 2, FALSE
2630 #ifndef PASN_NOPRINTON
2631     ,(const PASN_Names *)Names_H248_ServiceChangeResult,2
2632 #endif
2633 )
2634 {
2635 }
2636
2637
2638 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2639 H248_ServiceChangeResult::operator H248_ErrorDescriptor &() const
2640 #else
2641 H248_ServiceChangeResult::operator H248_ErrorDescriptor &()
2642 {
2643 #ifndef PASN_LEANANDMEAN
2644   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
2645 #endif
2646   return *(H248_ErrorDescriptor *)choice;
2647 }
2648
2649
2650 H248_ServiceChangeResult::operator const H248_ErrorDescriptor &() const
2651 #endif
2652 {
2653 #ifndef PASN_LEANANDMEAN
2654   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
2655 #endif
2656   return *(H248_ErrorDescriptor *)choice;
2657 }
2658
2659
2660 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2661 H248_ServiceChangeResult::operator H248_ServiceChangeResParm &() const
2662 #else
2663 H248_ServiceChangeResult::operator H248_ServiceChangeResParm &()
2664 {
2665 #ifndef PASN_LEANANDMEAN
2666   PAssert(PIsDescendant(PAssertNULL(choice), H248_ServiceChangeResParm), PInvalidCast);
2667 #endif
2668   return *(H248_ServiceChangeResParm *)choice;
2669 }
2670
2671
2672 H248_ServiceChangeResult::operator const H248_ServiceChangeResParm &() const
2673 #endif
2674 {
2675 #ifndef PASN_LEANANDMEAN
2676   PAssert(PIsDescendant(PAssertNULL(choice), H248_ServiceChangeResParm), PInvalidCast);
2677 #endif
2678   return *(H248_ServiceChangeResParm *)choice;
2679 }
2680
2681
2682 BOOL H248_ServiceChangeResult::CreateObject()
2683 {
2684   switch (tag) {
2685     case e_errorDescriptor :
2686       choice = new H248_ErrorDescriptor();
2687       return TRUE;
2688     case e_serviceChangeResParms :
2689       choice = new H248_ServiceChangeResParm();
2690       return TRUE;
2691   }
2692
2693   choice = NULL;
2694   return FALSE;
2695 }
2696
2697
2698 PObject * H248_ServiceChangeResult::Clone() const
2699 {
2700 #ifndef PASN_LEANANDMEAN
2701   PAssert(IsClass(H248_ServiceChangeResult::Class()), PInvalidCast);
2702 #endif
2703   return new H248_ServiceChangeResult(*this);
2704 }
2705
2706
2707 //
2708 // WildcardField
2709 //
2710
2711 H248_WildcardField::H248_WildcardField(unsigned tag, PASN_Object::TagClass tagClass)
2712   : PASN_OctetString(tag, tagClass)
2713 {
2714   SetConstraints(PASN_Object::FixedConstraint, 1);
2715 }
2716
2717
2718 H248_WildcardField::H248_WildcardField(const char * v)
2719 {
2720   SetValue(v);
2721 }
2722
2723
2724 H248_WildcardField::H248_WildcardField(const PString & v)
2725 {
2726   SetValue(v);
2727 }
2728
2729
2730 H248_WildcardField::H248_WildcardField(const PBYTEArray & v)
2731 {
2732   SetValue(v);
2733 }
2734
2735
2736 H248_WildcardField & H248_WildcardField::operator=(const char * v)
2737 {
2738   SetValue(v);
2739   return *this;
2740 }
2741
2742
2743 H248_WildcardField & H248_WildcardField::operator=(const PString & v)
2744 {
2745   SetValue(v);
2746   return *this;
2747 }
2748
2749
2750 H248_WildcardField & H248_WildcardField::operator=(const PBYTEArray & v)
2751 {
2752   SetValue(v);
2753   return *this;
2754 }
2755
2756
2757 PObject * H248_WildcardField::Clone() const
2758 {
2759 #ifndef PASN_LEANANDMEAN
2760   PAssert(IsClass(H248_WildcardField::Class()), PInvalidCast);
2761 #endif
2762   return new H248_WildcardField(*this);
2763 }
2764
2765
2766 //
2767 // TerminationIDList
2768 //
2769
2770 H248_TerminationIDList::H248_TerminationIDList(unsigned tag, PASN_Object::TagClass tagClass)
2771   : PASN_Array(tag, tagClass)
2772 {
2773 }
2774
2775
2776 PASN_Object * H248_TerminationIDList::CreateObject() const
2777 {
2778   return new H248_TerminationID;
2779 }
2780
2781
2782 H248_TerminationID & H248_TerminationIDList::operator[](PINDEX i) const
2783 {
2784   return (H248_TerminationID &)array[i];
2785 }
2786
2787
2788 PObject * H248_TerminationIDList::Clone() const
2789 {
2790 #ifndef PASN_LEANANDMEAN
2791   PAssert(IsClass(H248_TerminationIDList::Class()), PInvalidCast);
2792 #endif
2793   return new H248_TerminationIDList(*this);
2794 }
2795
2796
2797 #ifndef PASN_NOPRINTON
2798 const static PASN_Names Names_H248_StreamMode[]={
2799         {"sendOnly",0}
2800        ,{"recvOnly",1}
2801        ,{"sendRecv",2}
2802        ,{"inactive",3}
2803        ,{"loopBack",4}
2804 };
2805 #endif
2806 //
2807 // StreamMode
2808 //
2809
2810 H248_StreamMode::H248_StreamMode(unsigned tag, PASN_Object::TagClass tagClass)
2811   : PASN_Enumeration(tag, tagClass, 4, TRUE
2812 #ifndef PASN_NOPRINTON
2813     ,(const PASN_Names *)Names_H248_StreamMode,5
2814 #endif
2815     )
2816 {
2817 }
2818
2819
2820 H248_StreamMode & H248_StreamMode::operator=(unsigned v)
2821 {
2822   SetValue(v);
2823   return *this;
2824 }
2825
2826
2827 PObject * H248_StreamMode::Clone() const
2828 {
2829 #ifndef PASN_LEANANDMEAN
2830   PAssert(IsClass(H248_StreamMode::Class()), PInvalidCast);
2831 #endif
2832   return new H248_StreamMode(*this);
2833 }
2834
2835
2836 //
2837 // Name
2838 //
2839
2840 H248_Name::H248_Name(unsigned tag, PASN_Object::TagClass tagClass)
2841   : PASN_OctetString(tag, tagClass)
2842 {
2843   SetConstraints(PASN_Object::FixedConstraint, 2);
2844 }
2845
2846
2847 H248_Name::H248_Name(const char * v)
2848 {
2849   SetValue(v);
2850 }
2851
2852
2853 H248_Name::H248_Name(const PString & v)
2854 {
2855   SetValue(v);
2856 }
2857
2858
2859 H248_Name::H248_Name(const PBYTEArray & v)
2860 {
2861   SetValue(v);
2862 }
2863
2864
2865 H248_Name & H248_Name::operator=(const char * v)
2866 {
2867   SetValue(v);
2868   return *this;
2869 }
2870
2871
2872 H248_Name & H248_Name::operator=(const PString & v)
2873 {
2874   SetValue(v);
2875   return *this;
2876 }
2877
2878
2879 H248_Name & H248_Name::operator=(const PBYTEArray & v)
2880 {
2881   SetValue(v);
2882   return *this;
2883 }
2884
2885
2886 PObject * H248_Name::Clone() const
2887 {
2888 #ifndef PASN_LEANANDMEAN
2889   PAssert(IsClass(H248_Name::Class()), PInvalidCast);
2890 #endif
2891   return new H248_Name(*this);
2892 }
2893
2894
2895 //
2896 // PkgdName
2897 //
2898
2899 H248_PkgdName::H248_PkgdName(unsigned tag, PASN_Object::TagClass tagClass)
2900   : PASN_OctetString(tag, tagClass)
2901 {
2902   SetConstraints(PASN_Object::FixedConstraint, 4);
2903 }
2904
2905
2906 H248_PkgdName::H248_PkgdName(const char * v)
2907 {
2908   SetValue(v);
2909 }
2910
2911
2912 H248_PkgdName::H248_PkgdName(const PString & v)
2913 {
2914   SetValue(v);
2915 }
2916
2917
2918 H248_PkgdName::H248_PkgdName(const PBYTEArray & v)
2919 {
2920   SetValue(v);
2921 }
2922
2923
2924 H248_PkgdName & H248_PkgdName::operator=(const char * v)
2925 {
2926   SetValue(v);
2927   return *this;
2928 }
2929
2930
2931 H248_PkgdName & H248_PkgdName::operator=(const PString & v)
2932 {
2933   SetValue(v);
2934   return *this;
2935 }
2936
2937
2938 H248_PkgdName & H248_PkgdName::operator=(const PBYTEArray & v)
2939 {
2940   SetValue(v);
2941   return *this;
2942 }
2943
2944
2945 PObject * H248_PkgdName::Clone() const
2946 {
2947 #ifndef PASN_LEANANDMEAN
2948   PAssert(IsClass(H248_PkgdName::Class()), PInvalidCast);
2949 #endif
2950   return new H248_PkgdName(*this);
2951 }
2952
2953
2954 #ifndef PASN_NOPRINTON
2955 const static PASN_Names Names_H248_Relation[]={
2956         {"greaterThan",0}
2957        ,{"smallerThan",1}
2958        ,{"unequalTo",2}
2959 };
2960 #endif
2961 //
2962 // Relation
2963 //
2964
2965 H248_Relation::H248_Relation(unsigned tag, PASN_Object::TagClass tagClass)
2966   : PASN_Enumeration(tag, tagClass, 2, TRUE
2967 #ifndef PASN_NOPRINTON
2968     ,(const PASN_Names *)Names_H248_Relation,3
2969 #endif
2970     )
2971 {
2972 }
2973
2974
2975 H248_Relation & H248_Relation::operator=(unsigned v)
2976 {
2977   SetValue(v);
2978   return *this;
2979 }
2980
2981
2982 PObject * H248_Relation::Clone() const
2983 {
2984 #ifndef PASN_LEANANDMEAN
2985   PAssert(IsClass(H248_Relation::Class()), PInvalidCast);
2986 #endif
2987   return new H248_Relation(*this);
2988 }
2989
2990
2991 //
2992 // PropertyGroup
2993 //
2994
2995 H248_PropertyGroup::H248_PropertyGroup(unsigned tag, PASN_Object::TagClass tagClass)
2996   : PASN_Array(tag, tagClass)
2997 {
2998 }
2999
3000
3001 PASN_Object * H248_PropertyGroup::CreateObject() const
3002 {
3003   return new H248_PropertyParm;
3004 }
3005
3006
3007 H248_PropertyParm & H248_PropertyGroup::operator[](PINDEX i) const
3008 {
3009   return (H248_PropertyParm &)array[i];
3010 }
3011
3012
3013 PObject * H248_PropertyGroup::Clone() const
3014 {
3015 #ifndef PASN_LEANANDMEAN
3016   PAssert(IsClass(H248_PropertyGroup::Class()), PInvalidCast);
3017 #endif
3018   return new H248_PropertyGroup(*this);
3019 }
3020
3021
3022 #ifndef PASN_NOPRINTON
3023 const static PASN_Names Names_H248_EventBufferControl[]={
3024         {"off",0}
3025        ,{"lockStep",1}
3026 };
3027 #endif
3028 //
3029 // EventBufferControl
3030 //
3031
3032 H248_EventBufferControl::H248_EventBufferControl(unsigned tag, PASN_Object::TagClass tagClass)
3033   : PASN_Enumeration(tag, tagClass, 1, TRUE
3034 #ifndef PASN_NOPRINTON
3035     ,(const PASN_Names *)Names_H248_EventBufferControl,2
3036 #endif
3037     )
3038 {
3039 }
3040
3041
3042 H248_EventBufferControl & H248_EventBufferControl::operator=(unsigned v)
3043 {
3044   SetValue(v);
3045   return *this;
3046 }
3047
3048
3049 PObject * H248_EventBufferControl::Clone() const
3050 {
3051 #ifndef PASN_LEANANDMEAN
3052   PAssert(IsClass(H248_EventBufferControl::Class()), PInvalidCast);
3053 #endif
3054   return new H248_EventBufferControl(*this);
3055 }
3056
3057
3058 #ifndef PASN_NOPRINTON
3059 const static PASN_Names Names_H248_ServiceState[]={
3060         {"test",0}
3061        ,{"outOfSvc",1}
3062        ,{"inSvc",2}
3063 };
3064 #endif
3065 //
3066 // ServiceState
3067 //
3068
3069 H248_ServiceState::H248_ServiceState(unsigned tag, PASN_Object::TagClass tagClass)
3070   : PASN_Enumeration(tag, tagClass, 2, TRUE
3071 #ifndef PASN_NOPRINTON
3072     ,(const PASN_Names *)Names_H248_ServiceState,3
3073 #endif
3074     )
3075 {
3076 }
3077
3078
3079 H248_ServiceState & H248_ServiceState::operator=(unsigned v)
3080 {
3081   SetValue(v);
3082   return *this;
3083 }
3084
3085
3086 PObject * H248_ServiceState::Clone() const
3087 {
3088 #ifndef PASN_LEANANDMEAN
3089   PAssert(IsClass(H248_ServiceState::Class()), PInvalidCast);
3090 #endif
3091   return new H248_ServiceState(*this);
3092 }
3093
3094
3095 #ifndef PASN_NOPRINTON
3096 const static PASN_Names Names_H248_MuxType[]={
3097         {"h221",0}
3098        ,{"h223",1}
3099        ,{"h226",2}
3100        ,{"v76",3}
3101        ,{"nx64k",4}
3102 };
3103 #endif
3104 //
3105 // MuxType
3106 //
3107
3108 H248_MuxType::H248_MuxType(unsigned tag, PASN_Object::TagClass tagClass)
3109   : PASN_Enumeration(tag, tagClass, 4, TRUE
3110 #ifndef PASN_NOPRINTON
3111     ,(const PASN_Names *)Names_H248_MuxType,5
3112 #endif
3113     )
3114 {
3115 }
3116
3117
3118 H248_MuxType & H248_MuxType::operator=(unsigned v)
3119 {
3120   SetValue(v);
3121   return *this;
3122 }
3123
3124
3125 PObject * H248_MuxType::Clone() const
3126 {
3127 #ifndef PASN_LEANANDMEAN
3128   PAssert(IsClass(H248_MuxType::Class()), PInvalidCast);
3129 #endif
3130   return new H248_MuxType(*this);
3131 }
3132
3133
3134 //
3135 // StreamID
3136 //
3137
3138 H248_StreamID::H248_StreamID(unsigned tag, PASN_Object::TagClass tagClass)
3139   : PASN_Integer(tag, tagClass)
3140 {
3141   SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
3142 }
3143
3144
3145 H248_StreamID & H248_StreamID::operator=(int v)
3146 {
3147   SetValue(v);
3148   return *this;
3149 }
3150
3151
3152 H248_StreamID & H248_StreamID::operator=(unsigned v)
3153 {
3154   SetValue(v);
3155   return *this;
3156 }
3157
3158
3159 PObject * H248_StreamID::Clone() const
3160 {
3161 #ifndef PASN_LEANANDMEAN
3162   PAssert(IsClass(H248_StreamID::Class()), PInvalidCast);
3163 #endif
3164   return new H248_StreamID(*this);
3165 }
3166
3167
3168
3169 #ifndef PASN_NOPRINTON
3170 const static PASN_Names Names_H248_EventDM[]={
3171       {"digitMapName",0}
3172      ,{"digitMapValue",1}
3173 };
3174 #endif
3175 //
3176 // EventDM
3177 //
3178
3179 H248_EventDM::H248_EventDM(unsigned tag, PASN_Object::TagClass tagClass)
3180   : PASN_Choice(tag, tagClass, 2, FALSE
3181 #ifndef PASN_NOPRINTON
3182     ,(const PASN_Names *)Names_H248_EventDM,2
3183 #endif
3184 )
3185 {
3186 }
3187
3188
3189 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3190 H248_EventDM::operator H248_DigitMapName &() const
3191 #else
3192 H248_EventDM::operator H248_DigitMapName &()
3193 {
3194 #ifndef PASN_LEANANDMEAN
3195   PAssert(PIsDescendant(PAssertNULL(choice), H248_DigitMapName), PInvalidCast);
3196 #endif
3197   return *(H248_DigitMapName *)choice;
3198 }
3199
3200
3201 H248_EventDM::operator const H248_DigitMapName &() const
3202 #endif
3203 {
3204 #ifndef PASN_LEANANDMEAN
3205   PAssert(PIsDescendant(PAssertNULL(choice), H248_DigitMapName), PInvalidCast);
3206 #endif
3207   return *(H248_DigitMapName *)choice;
3208 }
3209
3210
3211 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3212 H248_EventDM::operator H248_DigitMapValue &() const
3213 #else
3214 H248_EventDM::operator H248_DigitMapValue &()
3215 {
3216 #ifndef PASN_LEANANDMEAN
3217   PAssert(PIsDescendant(PAssertNULL(choice), H248_DigitMapValue), PInvalidCast);
3218 #endif
3219   return *(H248_DigitMapValue *)choice;
3220 }
3221
3222
3223 H248_EventDM::operator const H248_DigitMapValue &() const
3224 #endif
3225 {
3226 #ifndef PASN_LEANANDMEAN
3227   PAssert(PIsDescendant(PAssertNULL(choice), H248_DigitMapValue), PInvalidCast);
3228 #endif
3229   return *(H248_DigitMapValue *)choice;
3230 }
3231
3232
3233 BOOL H248_EventDM::CreateObject()
3234 {
3235   switch (tag) {
3236     case e_digitMapName :
3237       choice = new H248_DigitMapName();
3238       return TRUE;
3239     case e_digitMapValue :
3240       choice = new H248_DigitMapValue();
3241       return TRUE;
3242   }
3243
3244   choice = NULL;
3245   return FALSE;
3246 }
3247
3248
3249 PObject * H248_EventDM::Clone() const
3250 {
3251 #ifndef PASN_LEANANDMEAN
3252   PAssert(IsClass(H248_EventDM::Class()), PInvalidCast);
3253 #endif
3254   return new H248_EventDM(*this);
3255 }
3256
3257
3258 //
3259 // EventBufferDescriptor
3260 //
3261
3262 H248_EventBufferDescriptor::H248_EventBufferDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
3263   : PASN_Array(tag, tagClass)
3264 {
3265 }
3266
3267
3268 PASN_Object * H248_EventBufferDescriptor::CreateObject() const
3269 {
3270   return new H248_EventSpec;
3271 }
3272
3273
3274 H248_EventSpec & H248_EventBufferDescriptor::operator[](PINDEX i) const
3275 {
3276   return (H248_EventSpec &)array[i];
3277 }
3278
3279
3280 PObject * H248_EventBufferDescriptor::Clone() const
3281 {
3282 #ifndef PASN_LEANANDMEAN
3283   PAssert(IsClass(H248_EventBufferDescriptor::Class()), PInvalidCast);
3284 #endif
3285   return new H248_EventBufferDescriptor(*this);
3286 }
3287
3288
3289 //
3290 // SignalsDescriptor
3291 //
3292
3293 H248_SignalsDescriptor::H248_SignalsDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
3294   : PASN_Array(tag, tagClass)
3295 {
3296 }
3297
3298
3299 PASN_Object * H248_SignalsDescriptor::CreateObject() const
3300 {
3301   return new H248_SignalRequest;
3302 }
3303
3304
3305 H248_SignalRequest & H248_SignalsDescriptor::operator[](PINDEX i) const
3306 {
3307   return (H248_SignalRequest &)array[i];
3308 }
3309
3310
3311 PObject * H248_SignalsDescriptor::Clone() const
3312 {
3313 #ifndef PASN_LEANANDMEAN
3314   PAssert(IsClass(H248_SignalsDescriptor::Class()), PInvalidCast);
3315 #endif
3316   return new H248_SignalsDescriptor(*this);
3317 }
3318
3319
3320
3321 #ifndef PASN_NOPRINTON
3322 const static PASN_Names Names_H248_SignalRequest[]={
3323       {"signal",0}
3324      ,{"seqSigList",1}
3325 };
3326 #endif
3327 //
3328 // SignalRequest
3329 //
3330
3331 H248_SignalRequest::H248_SignalRequest(unsigned tag, PASN_Object::TagClass tagClass)
3332   : PASN_Choice(tag, tagClass, 2, TRUE
3333 #ifndef PASN_NOPRINTON
3334     ,(const PASN_Names *)Names_H248_SignalRequest,2
3335 #endif
3336 )
3337 {
3338 }
3339
3340
3341 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3342 H248_SignalRequest::operator H248_Signal &() const
3343 #else
3344 H248_SignalRequest::operator H248_Signal &()
3345 {
3346 #ifndef PASN_LEANANDMEAN
3347   PAssert(PIsDescendant(PAssertNULL(choice), H248_Signal), PInvalidCast);
3348 #endif
3349   return *(H248_Signal *)choice;
3350 }
3351
3352
3353 H248_SignalRequest::operator const H248_Signal &() const
3354 #endif
3355 {
3356 #ifndef PASN_LEANANDMEAN
3357   PAssert(PIsDescendant(PAssertNULL(choice), H248_Signal), PInvalidCast);
3358 #endif
3359   return *(H248_Signal *)choice;
3360 }
3361
3362
3363 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3364 H248_SignalRequest::operator H248_SeqSigList &() const
3365 #else
3366 H248_SignalRequest::operator H248_SeqSigList &()
3367 {
3368 #ifndef PASN_LEANANDMEAN
3369   PAssert(PIsDescendant(PAssertNULL(choice), H248_SeqSigList), PInvalidCast);
3370 #endif
3371   return *(H248_SeqSigList *)choice;
3372 }
3373
3374
3375 H248_SignalRequest::operator const H248_SeqSigList &() const
3376 #endif
3377 {
3378 #ifndef PASN_LEANANDMEAN
3379   PAssert(PIsDescendant(PAssertNULL(choice), H248_SeqSigList), PInvalidCast);
3380 #endif
3381   return *(H248_SeqSigList *)choice;
3382 }
3383
3384
3385 BOOL H248_SignalRequest::CreateObject()
3386 {
3387   switch (tag) {
3388     case e_signal :
3389       choice = new H248_Signal();
3390       return TRUE;
3391     case e_seqSigList :
3392       choice = new H248_SeqSigList();
3393       return TRUE;
3394   }
3395
3396   choice = NULL;
3397   return FALSE;
3398 }
3399
3400
3401 PObject * H248_SignalRequest::Clone() const
3402 {
3403 #ifndef PASN_LEANANDMEAN
3404   PAssert(IsClass(H248_SignalRequest::Class()), PInvalidCast);
3405 #endif
3406   return new H248_SignalRequest(*this);
3407 }
3408
3409
3410 #ifndef PASN_NOPRINTON
3411 const static PASN_Names Names_H248_SignalType[]={
3412         {"brief",0}
3413        ,{"onOff",1}
3414        ,{"timeOut",2}
3415 };
3416 #endif
3417 //
3418 // SignalType
3419 //
3420
3421 H248_SignalType::H248_SignalType(unsigned tag, PASN_Object::TagClass tagClass)
3422   : PASN_Enumeration(tag, tagClass, 2, TRUE
3423 #ifndef PASN_NOPRINTON
3424     ,(const PASN_Names *)Names_H248_SignalType,3
3425 #endif
3426     )
3427 {
3428 }
3429
3430
3431 H248_SignalType & H248_SignalType::operator=(unsigned v)
3432 {
3433   SetValue(v);
3434   return *this;
3435 }
3436
3437
3438 PObject * H248_SignalType::Clone() const
3439 {
3440 #ifndef PASN_LEANANDMEAN
3441   PAssert(IsClass(H248_SignalType::Class()), PInvalidCast);
3442 #endif
3443   return new H248_SignalType(*this);
3444 }
3445
3446
3447 //
3448 // SignalName
3449 //
3450
3451 H248_SignalName::H248_SignalName(unsigned tag, PASN_Object::TagClass tagClass)
3452   : H248_PkgdName(tag, tagClass)
3453 {
3454 }
3455
3456
3457 H248_SignalName::H248_SignalName(const char * v)
3458 {
3459   SetValue(v);
3460 }
3461
3462
3463 H248_SignalName::H248_SignalName(const PString & v)
3464 {
3465   SetValue(v);
3466 }
3467
3468
3469 H248_SignalName::H248_SignalName(const PBYTEArray & v)
3470 {
3471   SetValue(v);
3472 }
3473
3474
3475 H248_SignalName & H248_SignalName::operator=(const char * v)
3476 {
3477   SetValue(v);
3478   return *this;
3479 }
3480
3481
3482 H248_SignalName & H248_SignalName::operator=(const PString & v)
3483 {
3484   SetValue(v);
3485   return *this;
3486 }
3487
3488
3489 H248_SignalName & H248_SignalName::operator=(const PBYTEArray & v)
3490 {
3491   SetValue(v);
3492   return *this;
3493 }
3494
3495
3496 PObject * H248_SignalName::Clone() const
3497 {
3498 #ifndef PASN_LEANANDMEAN
3499   PAssert(IsClass(H248_SignalName::Class()), PInvalidCast);
3500 #endif
3501   return new H248_SignalName(*this);
3502 }
3503
3504
3505 //
3506 // NotifyCompletion
3507 //
3508
3509 H248_NotifyCompletion::H248_NotifyCompletion(unsigned tag, PASN_Object::TagClass tagClass)
3510   : PASN_BitString(tag, tagClass)
3511 {
3512 }
3513
3514
3515 PObject * H248_NotifyCompletion::Clone() const
3516 {
3517 #ifndef PASN_LEANANDMEAN
3518   PAssert(IsClass(H248_NotifyCompletion::Class()), PInvalidCast);
3519 #endif
3520   return new H248_NotifyCompletion(*this);
3521 }
3522
3523
3524 //
3525 // RequestID
3526 //
3527
3528 H248_RequestID::H248_RequestID(unsigned tag, PASN_Object::TagClass tagClass)
3529   : PASN_Integer(tag, tagClass)
3530 {
3531   SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
3532 }
3533
3534
3535 H248_RequestID & H248_RequestID::operator=(int v)
3536 {
3537   SetValue(v);
3538   return *this;
3539 }
3540
3541
3542 H248_RequestID & H248_RequestID::operator=(unsigned v)
3543 {
3544   SetValue(v);
3545   return *this;
3546 }
3547
3548
3549 PObject * H248_RequestID::Clone() const
3550 {
3551 #ifndef PASN_LEANANDMEAN
3552   PAssert(IsClass(H248_RequestID::Class()), PInvalidCast);
3553 #endif
3554   return new H248_RequestID(*this);
3555 }
3556
3557
3558 #ifndef PASN_NOPRINTON
3559 const static PASN_Names Names_H248_ModemType[]={
3560         {"v18",0}
3561        ,{"v22",1}
3562        ,{"v22bis",2}
3563        ,{"v32",3}
3564        ,{"v32bis",4}
3565        ,{"v34",5}
3566        ,{"v90",6}
3567        ,{"v91",7}
3568        ,{"synchISDN",8}
3569 };
3570 #endif
3571 //
3572 // ModemType
3573 //
3574
3575 H248_ModemType::H248_ModemType(unsigned tag, PASN_Object::TagClass tagClass)
3576   : PASN_Enumeration(tag, tagClass, 8, TRUE
3577 #ifndef PASN_NOPRINTON
3578     ,(const PASN_Names *)Names_H248_ModemType,9
3579 #endif
3580     )
3581 {
3582 }
3583
3584
3585 H248_ModemType & H248_ModemType::operator=(unsigned v)
3586 {
3587   SetValue(v);
3588   return *this;
3589 }
3590
3591
3592 PObject * H248_ModemType::Clone() const
3593 {
3594 #ifndef PASN_LEANANDMEAN
3595   PAssert(IsClass(H248_ModemType::Class()), PInvalidCast);
3596 #endif
3597   return new H248_ModemType(*this);
3598 }
3599
3600
3601 //
3602 // DigitMapName
3603 //
3604
3605 H248_DigitMapName::H248_DigitMapName(unsigned tag, PASN_Object::TagClass tagClass)
3606   : H248_Name(tag, tagClass)
3607 {
3608 }
3609
3610
3611 H248_DigitMapName::H248_DigitMapName(const char * v)
3612 {
3613   SetValue(v);
3614 }
3615
3616
3617 H248_DigitMapName::H248_DigitMapName(const PString & v)
3618 {
3619   SetValue(v);
3620 }
3621
3622
3623 H248_DigitMapName::H248_DigitMapName(const PBYTEArray & v)
3624 {
3625   SetValue(v);
3626 }
3627
3628
3629 H248_DigitMapName & H248_DigitMapName::operator=(const char * v)
3630 {
3631   SetValue(v);
3632   return *this;
3633 }
3634
3635
3636 H248_DigitMapName & H248_DigitMapName::operator=(const PString & v)
3637 {
3638   SetValue(v);
3639   return *this;
3640 }
3641
3642
3643 H248_DigitMapName & H248_DigitMapName::operator=(const PBYTEArray & v)
3644 {
3645   SetValue(v);
3646   return *this;
3647 }
3648
3649
3650 PObject * H248_DigitMapName::Clone() const
3651 {
3652 #ifndef PASN_LEANANDMEAN
3653   PAssert(IsClass(H248_DigitMapName::Class()), PInvalidCast);
3654 #endif
3655   return new H248_DigitMapName(*this);
3656 }
3657
3658
3659 //
3660 // DigitMapValue
3661 //
3662
3663 H248_DigitMapValue::H248_DigitMapValue(unsigned tag, PASN_Object::TagClass tagClass)
3664   : PASN_Sequence(tag, tagClass, 3, TRUE, 1)
3665 {
3666   m_startTimer.SetConstraints(PASN_Object::FixedConstraint, 0, 99);
3667   m_shortTimer.SetConstraints(PASN_Object::FixedConstraint, 0, 99);
3668   m_longTimer.SetConstraints(PASN_Object::FixedConstraint, 0, 99);
3669   m_durationTimer.SetConstraints(PASN_Object::FixedConstraint, 0, 99);
3670 }
3671
3672
3673 #ifndef PASN_NOPRINTON
3674 void H248_DigitMapValue::PrintOn(ostream & strm) const
3675 {
3676   int indent = strm.precision() + 2;
3677   strm << "{\n";
3678   if (HasOptionalField(e_startTimer))
3679     strm << setw(indent+13) << "startTimer = " << setprecision(indent) << m_startTimer << '\n';
3680   if (HasOptionalField(e_shortTimer))
3681     strm << setw(indent+13) << "shortTimer = " << setprecision(indent) << m_shortTimer << '\n';
3682   if (HasOptionalField(e_longTimer))
3683     strm << setw(indent+12) << "longTimer = " << setprecision(indent) << m_longTimer << '\n';
3684   strm << setw(indent+15) << "digitMapBody = " << setprecision(indent) << m_digitMapBody << '\n';
3685   if (HasOptionalField(e_durationTimer))
3686     strm << setw(indent+16) << "durationTimer = " << setprecision(indent) << m_durationTimer << '\n';
3687   strm << setw(indent-1) << setprecision(indent-2) << "}";
3688 }
3689 #endif
3690
3691
3692 PObject::Comparison H248_DigitMapValue::Compare(const PObject & obj) const
3693 {
3694 #ifndef PASN_LEANANDMEAN
3695   PAssert(PIsDescendant(&obj, H248_DigitMapValue), PInvalidCast);
3696 #endif
3697   const H248_DigitMapValue & other = (const H248_DigitMapValue &)obj;
3698
3699   Comparison result;
3700
3701   if ((result = m_startTimer.Compare(other.m_startTimer)) != EqualTo)
3702     return result;
3703   if ((result = m_shortTimer.Compare(other.m_shortTimer)) != EqualTo)
3704     return result;
3705   if ((result = m_longTimer.Compare(other.m_longTimer)) != EqualTo)
3706     return result;
3707   if ((result = m_digitMapBody.Compare(other.m_digitMapBody)) != EqualTo)
3708     return result;
3709
3710   return PASN_Sequence::Compare(other);
3711 }
3712
3713
3714 PINDEX H248_DigitMapValue::GetDataLength() const
3715 {
3716   PINDEX length = 0;
3717   if (HasOptionalField(e_startTimer))
3718     length += m_startTimer.GetObjectLength();
3719   if (HasOptionalField(e_shortTimer))
3720     length += m_shortTimer.GetObjectLength();
3721   if (HasOptionalField(e_longTimer))
3722     length += m_longTimer.GetObjectLength();
3723   length += m_digitMapBody.GetObjectLength();
3724   return length;
3725 }
3726
3727
3728 BOOL H248_DigitMapValue::Decode(PASN_Stream & strm)
3729 {
3730   if (!PreambleDecode(strm))
3731     return FALSE;
3732
3733   if (HasOptionalField(e_startTimer) && !m_startTimer.Decode(strm))
3734     return FALSE;
3735   if (HasOptionalField(e_shortTimer) && !m_shortTimer.Decode(strm))
3736     return FALSE;
3737   if (HasOptionalField(e_longTimer) && !m_longTimer.Decode(strm))
3738     return FALSE;
3739   if (!m_digitMapBody.Decode(strm))
3740     return FALSE;
3741   if (!KnownExtensionDecode(strm, e_durationTimer, m_durationTimer))
3742     return FALSE;
3743
3744   return UnknownExtensionsDecode(strm);
3745 }
3746
3747
3748 void H248_DigitMapValue::Encode(PASN_Stream & strm) const
3749 {
3750   PreambleEncode(strm);
3751
3752   if (HasOptionalField(e_startTimer))
3753     m_startTimer.Encode(strm);
3754   if (HasOptionalField(e_shortTimer))
3755     m_shortTimer.Encode(strm);
3756   if (HasOptionalField(e_longTimer))
3757     m_longTimer.Encode(strm);
3758   m_digitMapBody.Encode(strm);
3759   KnownExtensionEncode(strm, e_durationTimer, m_durationTimer);
3760
3761   UnknownExtensionsEncode(strm);
3762 }
3763
3764
3765 PObject * H248_DigitMapValue::Clone() const
3766 {
3767 #ifndef PASN_LEANANDMEAN
3768   PAssert(IsClass(H248_DigitMapValue::Class()), PInvalidCast);
3769 #endif
3770   return new H248_DigitMapValue(*this);
3771 }
3772
3773
3774
3775 #ifndef PASN_NOPRINTON
3776 const static PASN_Names Names_H248_ServiceChangeAddress[]={
3777       {"portNumber",0}
3778      ,{"ip4Address",1}
3779      ,{"ip6Address",2}
3780      ,{"domainName",3}
3781      ,{"deviceName",4}
3782      ,{"mtpAddress",5}
3783 };
3784 #endif
3785 //
3786 // ServiceChangeAddress
3787 //
3788
3789 H248_ServiceChangeAddress::H248_ServiceChangeAddress(unsigned tag, PASN_Object::TagClass tagClass)
3790   : PASN_Choice(tag, tagClass, 6, TRUE
3791 #ifndef PASN_NOPRINTON
3792     ,(const PASN_Names *)Names_H248_ServiceChangeAddress,6
3793 #endif
3794 )
3795 {
3796 }
3797
3798
3799 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3800 H248_ServiceChangeAddress::operator H248_IP4Address &() const
3801 #else
3802 H248_ServiceChangeAddress::operator H248_IP4Address &()
3803 {
3804 #ifndef PASN_LEANANDMEAN
3805   PAssert(PIsDescendant(PAssertNULL(choice), H248_IP4Address), PInvalidCast);
3806 #endif
3807   return *(H248_IP4Address *)choice;
3808 }
3809
3810
3811 H248_ServiceChangeAddress::operator const H248_IP4Address &() const
3812 #endif
3813 {
3814 #ifndef PASN_LEANANDMEAN
3815   PAssert(PIsDescendant(PAssertNULL(choice), H248_IP4Address), PInvalidCast);
3816 #endif
3817   return *(H248_IP4Address *)choice;
3818 }
3819
3820
3821 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3822 H248_ServiceChangeAddress::operator H248_IP6Address &() const
3823 #else
3824 H248_ServiceChangeAddress::operator H248_IP6Address &()
3825 {
3826 #ifndef PASN_LEANANDMEAN
3827   PAssert(PIsDescendant(PAssertNULL(choice), H248_IP6Address), PInvalidCast);
3828 #endif
3829   return *(H248_IP6Address *)choice;
3830 }
3831
3832
3833 H248_ServiceChangeAddress::operator const H248_IP6Address &() const
3834 #endif
3835 {
3836 #ifndef PASN_LEANANDMEAN
3837   PAssert(PIsDescendant(PAssertNULL(choice), H248_IP6Address), PInvalidCast);
3838 #endif
3839   return *(H248_IP6Address *)choice;
3840 }
3841
3842
3843 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3844 H248_ServiceChangeAddress::operator H248_DomainName &() const
3845 #else
3846 H248_ServiceChangeAddress::operator H248_DomainName &()
3847 {
3848 #ifndef PASN_LEANANDMEAN
3849   PAssert(PIsDescendant(PAssertNULL(choice), H248_DomainName), PInvalidCast);
3850 #endif
3851   return *(H248_DomainName *)choice;
3852 }
3853
3854
3855 H248_ServiceChangeAddress::operator const H248_DomainName &() const
3856 #endif
3857 {
3858 #ifndef PASN_LEANANDMEAN
3859   PAssert(PIsDescendant(PAssertNULL(choice), H248_DomainName), PInvalidCast);
3860 #endif
3861   return *(H248_DomainName *)choice;
3862 }
3863
3864
3865 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3866 H248_ServiceChangeAddress::operator H248_PathName &() const
3867 #else
3868 H248_ServiceChangeAddress::operator H248_PathName &()
3869 {
3870 #ifndef PASN_LEANANDMEAN
3871   PAssert(PIsDescendant(PAssertNULL(choice), H248_PathName), PInvalidCast);
3872 #endif
3873   return *(H248_PathName *)choice;
3874 }
3875
3876
3877 H248_ServiceChangeAddress::operator const H248_PathName &() const
3878 #endif
3879 {
3880 #ifndef PASN_LEANANDMEAN
3881   PAssert(PIsDescendant(PAssertNULL(choice), H248_PathName), PInvalidCast);
3882 #endif
3883   return *(H248_PathName *)choice;
3884 }
3885
3886
3887 BOOL H248_ServiceChangeAddress::CreateObject()
3888 {
3889   switch (tag) {
3890     case e_portNumber :
3891       choice = new PASN_Integer();
3892       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
3893       return TRUE;
3894     case e_ip4Address :
3895       choice = new H248_IP4Address();
3896       return TRUE;
3897     case e_ip6Address :
3898       choice = new H248_IP6Address();
3899       return TRUE;
3900     case e_domainName :
3901       choice = new H248_DomainName();
3902       return TRUE;
3903     case e_deviceName :
3904       choice = new H248_PathName();
3905       return TRUE;
3906     case e_mtpAddress :
3907       choice = new PASN_OctetString();
3908       choice->SetConstraints(PASN_Object::FixedConstraint, 2, 4);
3909       return TRUE;
3910   }
3911
3912   choice = NULL;
3913   return FALSE;
3914 }
3915
3916
3917 PObject * H248_ServiceChangeAddress::Clone() const
3918 {
3919 #ifndef PASN_LEANANDMEAN
3920   PAssert(IsClass(H248_ServiceChangeAddress::Class()), PInvalidCast);
3921 #endif
3922   return new H248_ServiceChangeAddress(*this);
3923 }
3924
3925
3926 #ifndef PASN_NOPRINTON
3927 const static PASN_Names Names_H248_ServiceChangeMethod[]={
3928         {"failover",0}
3929        ,{"forced",1}
3930        ,{"graceful",2}
3931        ,{"restart",3}
3932        ,{"disconnected",4}
3933        ,{"handOff",5}
3934 };
3935 #endif
3936 //
3937 // ServiceChangeMethod
3938 //
3939
3940 H248_ServiceChangeMethod::H248_ServiceChangeMethod(unsigned tag, PASN_Object::TagClass tagClass)
3941   : PASN_Enumeration(tag, tagClass, 5, TRUE
3942 #ifndef PASN_NOPRINTON
3943     ,(const PASN_Names *)Names_H248_ServiceChangeMethod,6
3944 #endif
3945     )
3946 {
3947 }
3948
3949
3950 H248_ServiceChangeMethod & H248_ServiceChangeMethod::operator=(unsigned v)
3951 {
3952   SetValue(v);
3953   return *this;
3954 }
3955
3956
3957 PObject * H248_ServiceChangeMethod::Clone() const
3958 {
3959 #ifndef PASN_LEANANDMEAN
3960   PAssert(IsClass(H248_ServiceChangeMethod::Class()), PInvalidCast);
3961 #endif
3962   return new H248_ServiceChangeMethod(*this);
3963 }
3964
3965
3966 //
3967 // ServiceChangeProfile
3968 //
3969
3970 H248_ServiceChangeProfile::H248_ServiceChangeProfile(unsigned tag, PASN_Object::TagClass tagClass)
3971   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
3972 {
3973   m_profileName.SetConstraints(PASN_Object::FixedConstraint, 1, 67);
3974 }
3975
3976
3977 #ifndef PASN_NOPRINTON
3978 void H248_ServiceChangeProfile::PrintOn(ostream & strm) const
3979 {
3980   int indent = strm.precision() + 2;
3981   strm << "{\n";
3982   strm << setw(indent+14) << "profileName = " << setprecision(indent) << m_profileName << '\n';
3983   strm << setw(indent-1) << setprecision(indent-2) << "}";
3984 }
3985 #endif
3986
3987
3988 PObject::Comparison H248_ServiceChangeProfile::Compare(const PObject & obj) const
3989 {
3990 #ifndef PASN_LEANANDMEAN
3991   PAssert(PIsDescendant(&obj, H248_ServiceChangeProfile), PInvalidCast);
3992 #endif
3993   const H248_ServiceChangeProfile & other = (const H248_ServiceChangeProfile &)obj;
3994
3995   Comparison result;
3996
3997   if ((result = m_profileName.Compare(other.m_profileName)) != EqualTo)
3998     return result;
3999
4000   return PASN_Sequence::Compare(other);
4001 }
4002
4003
4004 PINDEX H248_ServiceChangeProfile::GetDataLength() const
4005 {
4006   PINDEX length = 0;
4007   length += m_profileName.GetObjectLength();
4008   return length;
4009 }
4010
4011
4012 BOOL H248_ServiceChangeProfile::Decode(PASN_Stream & strm)
4013 {
4014   if (!PreambleDecode(strm))
4015     return FALSE;
4016
4017   if (!m_profileName.Decode(strm))
4018     return FALSE;
4019
4020   return UnknownExtensionsDecode(strm);
4021 }
4022
4023
4024 void H248_ServiceChangeProfile::Encode(PASN_Stream & strm) const
4025 {
4026   PreambleEncode(strm);
4027
4028   m_profileName.Encode(strm);
4029
4030   UnknownExtensionsEncode(strm);
4031 }
4032
4033
4034 PObject * H248_ServiceChangeProfile::Clone() const
4035 {
4036 #ifndef PASN_LEANANDMEAN
4037   PAssert(IsClass(H248_ServiceChangeProfile::Class()), PInvalidCast);
4038 #endif
4039   return new H248_ServiceChangeProfile(*this);
4040 }
4041
4042
4043 //
4044 // PackagesDescriptor
4045 //
4046
4047 H248_PackagesDescriptor::H248_PackagesDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
4048   : PASN_Array(tag, tagClass)
4049 {
4050 }
4051
4052
4053 PASN_Object * H248_PackagesDescriptor::CreateObject() const
4054 {
4055   return new H248_PackagesItem;
4056 }
4057
4058
4059 H248_PackagesItem & H248_PackagesDescriptor::operator[](PINDEX i) const
4060 {
4061   return (H248_PackagesItem &)array[i];
4062 }
4063
4064
4065 PObject * H248_PackagesDescriptor::Clone() const
4066 {
4067 #ifndef PASN_LEANANDMEAN
4068   PAssert(IsClass(H248_PackagesDescriptor::Class()), PInvalidCast);
4069 #endif
4070   return new H248_PackagesDescriptor(*this);
4071 }
4072
4073
4074 //
4075 // PackagesItem
4076 //
4077
4078 H248_PackagesItem::H248_PackagesItem(unsigned tag, PASN_Object::TagClass tagClass)
4079   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
4080 {
4081   m_packageVersion.SetConstraints(PASN_Object::FixedConstraint, 0, 99);
4082 }
4083
4084
4085 #ifndef PASN_NOPRINTON
4086 void H248_PackagesItem::PrintOn(ostream & strm) const
4087 {
4088   int indent = strm.precision() + 2;
4089   strm << "{\n";
4090   strm << setw(indent+14) << "packageName = " << setprecision(indent) << m_packageName << '\n';
4091   strm << setw(indent+17) << "packageVersion = " << setprecision(indent) << m_packageVersion << '\n';
4092   strm << setw(indent-1) << setprecision(indent-2) << "}";
4093 }
4094 #endif
4095
4096
4097 PObject::Comparison H248_PackagesItem::Compare(const PObject & obj) const
4098 {
4099 #ifndef PASN_LEANANDMEAN
4100   PAssert(PIsDescendant(&obj, H248_PackagesItem), PInvalidCast);
4101 #endif
4102   const H248_PackagesItem & other = (const H248_PackagesItem &)obj;
4103
4104   Comparison result;
4105
4106   if ((result = m_packageName.Compare(other.m_packageName)) != EqualTo)
4107     return result;
4108   if ((result = m_packageVersion.Compare(other.m_packageVersion)) != EqualTo)
4109     return result;
4110
4111   return PASN_Sequence::Compare(other);
4112 }
4113
4114
4115 PINDEX H248_PackagesItem::GetDataLength() const
4116 {
4117   PINDEX length = 0;
4118   length += m_packageName.GetObjectLength();
4119   length += m_packageVersion.GetObjectLength();
4120   return length;
4121 }
4122
4123
4124 BOOL H248_PackagesItem::Decode(PASN_Stream & strm)
4125 {
4126   if (!PreambleDecode(strm))
4127     return FALSE;
4128
4129   if (!m_packageName.Decode(strm))
4130     return FALSE;
4131   if (!m_packageVersion.Decode(strm))
4132     return FALSE;
4133
4134   return UnknownExtensionsDecode(strm);
4135 }
4136
4137
4138 void H248_PackagesItem::Encode(PASN_Stream & strm) const
4139 {
4140   PreambleEncode(strm);
4141
4142   m_packageName.Encode(strm);
4143   m_packageVersion.Encode(strm);
4144
4145   UnknownExtensionsEncode(strm);
4146 }
4147
4148
4149 PObject * H248_PackagesItem::Clone() const
4150 {
4151 #ifndef PASN_LEANANDMEAN
4152   PAssert(IsClass(H248_PackagesItem::Class()), PInvalidCast);
4153 #endif
4154   return new H248_PackagesItem(*this);
4155 }
4156
4157
4158 //
4159 // StatisticsDescriptor
4160 //
4161
4162 H248_StatisticsDescriptor::H248_StatisticsDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
4163   : PASN_Array(tag, tagClass)
4164 {
4165 }
4166
4167
4168 PASN_Object * H248_StatisticsDescriptor::CreateObject() const
4169 {
4170   return new H248_StatisticsParameter;
4171 }
4172
4173
4174 H248_StatisticsParameter & H248_StatisticsDescriptor::operator[](PINDEX i) const
4175 {
4176   return (H248_StatisticsParameter &)array[i];
4177 }
4178
4179
4180 PObject * H248_StatisticsDescriptor::Clone() const
4181 {
4182 #ifndef PASN_LEANANDMEAN
4183   PAssert(IsClass(H248_StatisticsDescriptor::Class()), PInvalidCast);
4184 #endif
4185   return new H248_StatisticsDescriptor(*this);
4186 }
4187
4188
4189
4190 #ifndef PASN_NOPRINTON
4191 const static PASN_Names Names_H248_NonStandardIdentifier[]={
4192       {"object",0}
4193      ,{"h221NonStandard",1}
4194      ,{"experimental",2}
4195 };
4196 #endif
4197 //
4198 // NonStandardIdentifier
4199 //
4200
4201 H248_NonStandardIdentifier::H248_NonStandardIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
4202   : PASN_Choice(tag, tagClass, 3, TRUE
4203 #ifndef PASN_NOPRINTON
4204     ,(const PASN_Names *)Names_H248_NonStandardIdentifier,3
4205 #endif
4206 )
4207 {
4208 }
4209
4210
4211 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4212 H248_NonStandardIdentifier::operator H248_H221NonStandard &() const
4213 #else
4214 H248_NonStandardIdentifier::operator H248_H221NonStandard &()
4215 {
4216 #ifndef PASN_LEANANDMEAN
4217   PAssert(PIsDescendant(PAssertNULL(choice), H248_H221NonStandard), PInvalidCast);
4218 #endif
4219   return *(H248_H221NonStandard *)choice;
4220 }
4221
4222
4223 H248_NonStandardIdentifier::operator const H248_H221NonStandard &() const
4224 #endif
4225 {
4226 #ifndef PASN_LEANANDMEAN
4227   PAssert(PIsDescendant(PAssertNULL(choice), H248_H221NonStandard), PInvalidCast);
4228 #endif
4229   return *(H248_H221NonStandard *)choice;
4230 }
4231
4232
4233 BOOL H248_NonStandardIdentifier::CreateObject()
4234 {
4235   switch (tag) {
4236     case e_object :
4237       choice = new PASN_ObjectId();
4238       return TRUE;
4239     case e_h221NonStandard :
4240       choice = new H248_H221NonStandard();
4241       return TRUE;
4242     case e_experimental :
4243       choice = new PASN_IA5String();
4244       choice->SetConstraints(PASN_Object::FixedConstraint, 8);
4245       return TRUE;
4246   }
4247
4248   choice = NULL;
4249   return FALSE;
4250 }
4251
4252
4253 PObject * H248_NonStandardIdentifier::Clone() const
4254 {
4255 #ifndef PASN_LEANANDMEAN
4256   PAssert(IsClass(H248_NonStandardIdentifier::Class()), PInvalidCast);
4257 #endif
4258   return new H248_NonStandardIdentifier(*this);
4259 }
4260
4261
4262 //
4263 // H221NonStandard
4264 //
4265
4266 H248_H221NonStandard::H248_H221NonStandard(unsigned tag, PASN_Object::TagClass tagClass)
4267   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
4268 {
4269   m_t35CountryCode1.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
4270   m_t35CountryCode2.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
4271   m_t35Extension.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
4272   m_manufacturerCode.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
4273 }
4274
4275
4276 #ifndef PASN_NOPRINTON
4277 void H248_H221NonStandard::PrintOn(ostream & strm) const
4278 {
4279   int indent = strm.precision() + 2;
4280   strm << "{\n";
4281   strm << setw(indent+18) << "t35CountryCode1 = " << setprecision(indent) << m_t35CountryCode1 << '\n';
4282   strm << setw(indent+18) << "t35CountryCode2 = " << setprecision(indent) << m_t35CountryCode2 << '\n';
4283   strm << setw(indent+15) << "t35Extension = " << setprecision(indent) << m_t35Extension << '\n';
4284   strm << setw(indent+19) << "manufacturerCode = " << setprecision(indent) << m_manufacturerCode << '\n';
4285   strm << setw(indent-1) << setprecision(indent-2) << "}";
4286 }
4287 #endif
4288
4289
4290 PObject::Comparison H248_H221NonStandard::Compare(const PObject & obj) const
4291 {
4292 #ifndef PASN_LEANANDMEAN
4293   PAssert(PIsDescendant(&obj, H248_H221NonStandard), PInvalidCast);
4294 #endif
4295   const H248_H221NonStandard & other = (const H248_H221NonStandard &)obj;
4296
4297   Comparison result;
4298
4299   if ((result = m_t35CountryCode1.Compare(other.m_t35CountryCode1)) != EqualTo)
4300     return result;
4301   if ((result = m_t35CountryCode2.Compare(other.m_t35CountryCode2)) != EqualTo)
4302     return result;
4303   if ((result = m_t35Extension.Compare(other.m_t35Extension)) != EqualTo)
4304     return result;
4305   if ((result = m_manufacturerCode.Compare(other.m_manufacturerCode)) != EqualTo)
4306     return result;
4307
4308   return PASN_Sequence::Compare(other);
4309 }
4310
4311
4312 PINDEX H248_H221NonStandard::GetDataLength() const
4313 {
4314   PINDEX length = 0;
4315   length += m_t35CountryCode1.GetObjectLength();
4316   length += m_t35CountryCode2.GetObjectLength();
4317   length += m_t35Extension.GetObjectLength();
4318   length += m_manufacturerCode.GetObjectLength();
4319   return length;
4320 }
4321
4322
4323 BOOL H248_H221NonStandard::Decode(PASN_Stream & strm)
4324 {
4325   if (!PreambleDecode(strm))
4326     return FALSE;
4327
4328   if (!m_t35CountryCode1.Decode(strm))
4329     return FALSE;
4330   if (!m_t35CountryCode2.Decode(strm))
4331     return FALSE;
4332   if (!m_t35Extension.Decode(strm))
4333     return FALSE;
4334   if (!m_manufacturerCode.Decode(strm))
4335     return FALSE;
4336
4337   return UnknownExtensionsDecode(strm);
4338 }
4339
4340
4341 void H248_H221NonStandard::Encode(PASN_Stream & strm) const
4342 {
4343   PreambleEncode(strm);
4344
4345   m_t35CountryCode1.Encode(strm);
4346   m_t35CountryCode2.Encode(strm);
4347   m_t35Extension.Encode(strm);
4348   m_manufacturerCode.Encode(strm);
4349
4350   UnknownExtensionsEncode(strm);
4351 }
4352
4353
4354 PObject * H248_H221NonStandard::Clone() const
4355 {
4356 #ifndef PASN_LEANANDMEAN
4357   PAssert(IsClass(H248_H221NonStandard::Class()), PInvalidCast);
4358 #endif
4359   return new H248_H221NonStandard(*this);
4360 }
4361
4362
4363 //
4364 // TimeNotation
4365 //
4366
4367 H248_TimeNotation::H248_TimeNotation(unsigned tag, PASN_Object::TagClass tagClass)
4368   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
4369 {
4370   m_date.SetConstraints(PASN_Object::FixedConstraint, 8);
4371   m_time.SetConstraints(PASN_Object::FixedConstraint, 8);
4372 }
4373
4374
4375 #ifndef PASN_NOPRINTON
4376 void H248_TimeNotation::PrintOn(ostream & strm) const
4377 {
4378   int indent = strm.precision() + 2;
4379   strm << "{\n";
4380   strm << setw(indent+7) << "date = " << setprecision(indent) << m_date << '\n';
4381   strm << setw(indent+7) << "time = " << setprecision(indent) << m_time << '\n';
4382   strm << setw(indent-1) << setprecision(indent-2) << "}";
4383 }
4384 #endif
4385
4386
4387 PObject::Comparison H248_TimeNotation::Compare(const PObject & obj) const
4388 {
4389 #ifndef PASN_LEANANDMEAN
4390   PAssert(PIsDescendant(&obj, H248_TimeNotation), PInvalidCast);
4391 #endif
4392   const H248_TimeNotation & other = (const H248_TimeNotation &)obj;
4393
4394   Comparison result;
4395
4396   if ((result = m_date.Compare(other.m_date)) != EqualTo)
4397     return result;
4398   if ((result = m_time.Compare(other.m_time)) != EqualTo)
4399     return result;
4400
4401   return PASN_Sequence::Compare(other);
4402 }
4403
4404
4405 PINDEX H248_TimeNotation::GetDataLength() const
4406 {
4407   PINDEX length = 0;
4408   length += m_date.GetObjectLength();
4409   length += m_time.GetObjectLength();
4410   return length;
4411 }
4412
4413
4414 BOOL H248_TimeNotation::Decode(PASN_Stream & strm)
4415 {
4416   if (!PreambleDecode(strm))
4417     return FALSE;
4418
4419   if (!m_date.Decode(strm))
4420     return FALSE;
4421   if (!m_time.Decode(strm))
4422     return FALSE;
4423
4424   return UnknownExtensionsDecode(strm);
4425 }
4426
4427
4428 void H248_TimeNotation::Encode(PASN_Stream & strm) const
4429 {
4430   PreambleEncode(strm);
4431
4432   m_date.Encode(strm);
4433   m_time.Encode(strm);
4434
4435   UnknownExtensionsEncode(strm);
4436 }
4437
4438
4439 PObject * H248_TimeNotation::Clone() const
4440 {
4441 #ifndef PASN_LEANANDMEAN
4442   PAssert(IsClass(H248_TimeNotation::Class()), PInvalidCast);
4443 #endif
4444   return new H248_TimeNotation(*this);
4445 }
4446
4447
4448 //
4449 // Value
4450 //
4451
4452 H248_Value::H248_Value(unsigned tag, PASN_Object::TagClass tagClass)
4453   : PASN_Array(tag, tagClass)
4454 {
4455 }
4456
4457
4458 PASN_Object * H248_Value::CreateObject() const
4459 {
4460   return new PASN_OctetString;
4461 }
4462
4463
4464 PASN_OctetString & H248_Value::operator[](PINDEX i) const
4465 {
4466   return (PASN_OctetString &)array[i];
4467 }
4468
4469
4470 PObject * H248_Value::Clone() const
4471 {
4472 #ifndef PASN_LEANANDMEAN
4473   PAssert(IsClass(H248_Value::Class()), PInvalidCast);
4474 #endif
4475   return new H248_Value(*this);
4476 }
4477
4478
4479
4480 #ifndef PASN_NOPRINTON
4481 const static PASN_Names Names_H248_Message_messageBody[]={
4482       {"messageError",0}
4483      ,{"transactions",1}
4484 };
4485 #endif
4486 //
4487 // Message_messageBody
4488 //
4489
4490 H248_Message_messageBody::H248_Message_messageBody(unsigned tag, PASN_Object::TagClass tagClass)
4491   : PASN_Choice(tag, tagClass, 2, FALSE
4492 #ifndef PASN_NOPRINTON
4493     ,(const PASN_Names *)Names_H248_Message_messageBody,2
4494 #endif
4495 )
4496 {
4497 }
4498
4499
4500 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4501 H248_Message_messageBody::operator H248_ErrorDescriptor &() const
4502 #else
4503 H248_Message_messageBody::operator H248_ErrorDescriptor &()
4504 {
4505 #ifndef PASN_LEANANDMEAN
4506   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
4507 #endif
4508   return *(H248_ErrorDescriptor *)choice;
4509 }
4510
4511
4512 H248_Message_messageBody::operator const H248_ErrorDescriptor &() const
4513 #endif
4514 {
4515 #ifndef PASN_LEANANDMEAN
4516   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
4517 #endif
4518   return *(H248_ErrorDescriptor *)choice;
4519 }
4520
4521
4522 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4523 H248_Message_messageBody::operator H248_ArrayOf_Transaction &() const
4524 #else
4525 H248_Message_messageBody::operator H248_ArrayOf_Transaction &()
4526 {
4527 #ifndef PASN_LEANANDMEAN
4528   PAssert(PIsDescendant(PAssertNULL(choice), H248_ArrayOf_Transaction), PInvalidCast);
4529 #endif
4530   return *(H248_ArrayOf_Transaction *)choice;
4531 }
4532
4533
4534 H248_Message_messageBody::operator const H248_ArrayOf_Transaction &() const
4535 #endif
4536 {
4537 #ifndef PASN_LEANANDMEAN
4538   PAssert(PIsDescendant(PAssertNULL(choice), H248_ArrayOf_Transaction), PInvalidCast);
4539 #endif
4540   return *(H248_ArrayOf_Transaction *)choice;
4541 }
4542
4543
4544 BOOL H248_Message_messageBody::CreateObject()
4545 {
4546   switch (tag) {
4547     case e_messageError :
4548       choice = new H248_ErrorDescriptor();
4549       return TRUE;
4550     case e_transactions :
4551       choice = new H248_ArrayOf_Transaction();
4552       return TRUE;
4553   }
4554
4555   choice = NULL;
4556   return FALSE;
4557 }
4558
4559
4560 PObject * H248_Message_messageBody::Clone() const
4561 {
4562 #ifndef PASN_LEANANDMEAN
4563   PAssert(IsClass(H248_Message_messageBody::Class()), PInvalidCast);
4564 #endif
4565   return new H248_Message_messageBody(*this);
4566 }
4567
4568
4569 //
4570 // ArrayOf_ActionRequest
4571 //
4572
4573 H248_ArrayOf_ActionRequest::H248_ArrayOf_ActionRequest(unsigned tag, PASN_Object::TagClass tagClass)
4574   : PASN_Array(tag, tagClass)
4575 {
4576 }
4577
4578
4579 PASN_Object * H248_ArrayOf_ActionRequest::CreateObject() const
4580 {
4581   return new H248_ActionRequest;
4582 }
4583
4584
4585 H248_ActionRequest & H248_ArrayOf_ActionRequest::operator[](PINDEX i) const
4586 {
4587   return (H248_ActionRequest &)array[i];
4588 }
4589
4590
4591 PObject * H248_ArrayOf_ActionRequest::Clone() const
4592 {
4593 #ifndef PASN_LEANANDMEAN
4594   PAssert(IsClass(H248_ArrayOf_ActionRequest::Class()), PInvalidCast);
4595 #endif
4596   return new H248_ArrayOf_ActionRequest(*this);
4597 }
4598
4599
4600
4601 #ifndef PASN_NOPRINTON
4602 const static PASN_Names Names_H248_TransactionReply_transactionResult[]={
4603       {"transactionError",0}
4604      ,{"actionReplies",1}
4605 };
4606 #endif
4607 //
4608 // TransactionReply_transactionResult
4609 //
4610
4611 H248_TransactionReply_transactionResult::H248_TransactionReply_transactionResult(unsigned tag, PASN_Object::TagClass tagClass)
4612   : PASN_Choice(tag, tagClass, 2, FALSE
4613 #ifndef PASN_NOPRINTON
4614     ,(const PASN_Names *)Names_H248_TransactionReply_transactionResult,2
4615 #endif
4616 )
4617 {
4618 }
4619
4620
4621 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4622 H248_TransactionReply_transactionResult::operator H248_ErrorDescriptor &() const
4623 #else
4624 H248_TransactionReply_transactionResult::operator H248_ErrorDescriptor &()
4625 {
4626 #ifndef PASN_LEANANDMEAN
4627   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
4628 #endif
4629   return *(H248_ErrorDescriptor *)choice;
4630 }
4631
4632
4633 H248_TransactionReply_transactionResult::operator const H248_ErrorDescriptor &() const
4634 #endif
4635 {
4636 #ifndef PASN_LEANANDMEAN
4637   PAssert(PIsDescendant(PAssertNULL(choice), H248_ErrorDescriptor), PInvalidCast);
4638 #endif
4639   return *(H248_ErrorDescriptor *)choice;
4640 }
4641
4642
4643 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4644 H248_TransactionReply_transactionResult::operator H248_ArrayOf_ActionReply &() const
4645 #else
4646 H248_TransactionReply_transactionResult::operator H248_ArrayOf_ActionReply &()
4647 {
4648 #ifndef PASN_LEANANDMEAN
4649   PAssert(PIsDescendant(PAssertNULL(choice), H248_ArrayOf_ActionReply), PInvalidCast);
4650 #endif
4651   return *(H248_ArrayOf_ActionReply *)choice;
4652 }
4653
4654
4655 H248_TransactionReply_transactionResult::operator const H248_ArrayOf_ActionReply &() const
4656 #endif
4657 {
4658 #ifndef PASN_LEANANDMEAN
4659   PAssert(PIsDescendant(PAssertNULL(choice), H248_ArrayOf_ActionReply), PInvalidCast);
4660 #endif
4661   return *(H248_ArrayOf_ActionReply *)choice;
4662 }
4663
4664
4665 BOOL H248_TransactionReply_transactionResult::CreateObject()
4666 {
4667   switch (tag) {
4668     case e_transactionError :
4669       choice = new H248_ErrorDescriptor();
4670       return TRUE;
4671     case e_actionReplies :
4672       choice = new H248_ArrayOf_ActionReply();
4673       return TRUE;
4674   }
4675
4676   choice = NULL;
4677   return FALSE;
4678 }
4679
4680
4681 PObject * H248_TransactionReply_transactionResult::Clone() const
4682 {
4683 #ifndef PASN_LEANANDMEAN
4684   PAssert(IsClass(H248_TransactionReply_transactionResult::Class()), PInvalidCast);
4685 #endif
4686   return new H248_TransactionReply_transactionResult(*this);
4687 }
4688
4689
4690 //
4691 // ArrayOf_CommandRequest
4692 //
4693
4694 H248_ArrayOf_CommandRequest::H248_ArrayOf_CommandRequest(unsigned tag, PASN_Object::TagClass tagClass)
4695   : PASN_Array(tag, tagClass)
4696 {
4697 }
4698
4699
4700 PASN_Object * H248_ArrayOf_CommandRequest::CreateObject() const
4701 {
4702   return new H248_CommandRequest;
4703 }
4704
4705
4706 H248_CommandRequest & H248_ArrayOf_CommandRequest::operator[](PINDEX i) const
4707 {
4708   return (H248_CommandRequest &)array[i];
4709 }
4710
4711
4712 PObject * H248_ArrayOf_CommandRequest::Clone() const
4713 {
4714 #ifndef PASN_LEANANDMEAN
4715   PAssert(IsClass(H248_ArrayOf_CommandRequest::Class()), PInvalidCast);
4716 #endif
4717   return new H248_ArrayOf_CommandRequest(*this);
4718 }
4719
4720
4721 //
4722 // ArrayOf_CommandReply
4723 //
4724
4725 H248_ArrayOf_CommandReply::H248_ArrayOf_CommandReply(unsigned tag, PASN_Object::TagClass tagClass)
4726   : PASN_Array(tag, tagClass)
4727 {
4728 }
4729
4730
4731 PASN_Object * H248_ArrayOf_CommandReply::CreateObject() const
4732 {
4733   return new H248_CommandReply;
4734 }
4735
4736
4737 H248_CommandReply & H248_ArrayOf_CommandReply::operator[](PINDEX i) const
4738 {
4739   return (H248_CommandReply &)array[i];
4740 }
4741
4742
4743 PObject * H248_ArrayOf_CommandReply::Clone() const
4744 {
4745 #ifndef PASN_LEANANDMEAN
4746   PAssert(IsClass(H248_ArrayOf_CommandReply::Class()), PInvalidCast);
4747 #endif
4748   return new H248_ArrayOf_CommandReply(*this);
4749 }
4750
4751
4752 //
4753 // ArrayOf_TopologyRequest
4754 //
4755
4756 H248_ArrayOf_TopologyRequest::H248_ArrayOf_TopologyRequest(unsigned tag, PASN_Object::TagClass tagClass)
4757   : PASN_Array(tag, tagClass)
4758 {
4759 }
4760
4761
4762 PASN_Object * H248_ArrayOf_TopologyRequest::CreateObject() const
4763 {
4764   return new H248_TopologyRequest;
4765 }
4766
4767
4768 H248_TopologyRequest & H248_ArrayOf_TopologyRequest::operator[](PINDEX i) const
4769 {
4770   return (H248_TopologyRequest &)array[i];
4771 }
4772
4773
4774 PObject * H248_ArrayOf_TopologyRequest::Clone() const
4775 {
4776 #ifndef PASN_LEANANDMEAN
4777   PAssert(IsClass(H248_ArrayOf_TopologyRequest::Class()), PInvalidCast);
4778 #endif
4779   return new H248_ArrayOf_TopologyRequest(*this);
4780 }
4781
4782
4783 #ifndef PASN_NOPRINTON
4784 const static PASN_Names Names_H248_TopologyRequest_topologyDirection[]={
4785         {"bothway",0}
4786        ,{"isolate",1}
4787        ,{"oneway",2}
4788 };
4789 #endif
4790 //
4791 // TopologyRequest_topologyDirection
4792 //
4793
4794 H248_TopologyRequest_topologyDirection::H248_TopologyRequest_topologyDirection(unsigned tag, PASN_Object::TagClass tagClass)
4795   : PASN_Enumeration(tag, tagClass, 2, FALSE
4796 #ifndef PASN_NOPRINTON
4797     ,(const PASN_Names *)Names_H248_TopologyRequest_topologyDirection,3
4798 #endif
4799     )
4800 {
4801 }
4802
4803
4804 H248_TopologyRequest_topologyDirection & H248_TopologyRequest_topologyDirection::operator=(unsigned v)
4805 {
4806   SetValue(v);
4807   return *this;
4808 }
4809
4810
4811 PObject * H248_TopologyRequest_topologyDirection::Clone() const
4812 {
4813 #ifndef PASN_LEANANDMEAN
4814   PAssert(IsClass(H248_TopologyRequest_topologyDirection::Class()), PInvalidCast);
4815 #endif
4816   return new H248_TopologyRequest_topologyDirection(*this);
4817 }
4818
4819
4820 //
4821 // ArrayOf_AmmDescriptor
4822 //
4823
4824 H248_ArrayOf_AmmDescriptor::H248_ArrayOf_AmmDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
4825   : PASN_Array(tag, tagClass)
4826 {
4827 }
4828
4829
4830 PASN_Object * H248_ArrayOf_AmmDescriptor::CreateObject() const
4831 {
4832   return new H248_AmmDescriptor;
4833 }
4834
4835
4836 H248_AmmDescriptor & H248_ArrayOf_AmmDescriptor::operator[](PINDEX i) const
4837 {
4838   return (H248_AmmDescriptor &)array[i];
4839 }
4840
4841
4842 PObject * H248_ArrayOf_AmmDescriptor::Clone() const
4843 {
4844 #ifndef PASN_LEANANDMEAN
4845   PAssert(IsClass(H248_ArrayOf_AmmDescriptor::Class()), PInvalidCast);
4846 #endif
4847   return new H248_ArrayOf_AmmDescriptor(*this);
4848 }
4849
4850
4851 //
4852 // ArrayOf_IndAuditParameter
4853 //
4854
4855 H248_ArrayOf_IndAuditParameter::H248_ArrayOf_IndAuditParameter(unsigned tag, PASN_Object::TagClass tagClass)
4856   : PASN_Array(tag, tagClass)
4857 {
4858 }
4859
4860
4861 PASN_Object * H248_ArrayOf_IndAuditParameter::CreateObject() const
4862 {
4863   return new H248_IndAuditParameter;
4864 }
4865
4866
4867 H248_IndAuditParameter & H248_ArrayOf_IndAuditParameter::operator[](PINDEX i) const
4868 {
4869   return (H248_IndAuditParameter &)array[i];
4870 }
4871
4872
4873 PObject * H248_ArrayOf_IndAuditParameter::Clone() const
4874 {
4875 #ifndef PASN_LEANANDMEAN
4876   PAssert(IsClass(H248_ArrayOf_IndAuditParameter::Class()), PInvalidCast);
4877 #endif
4878   return new H248_ArrayOf_IndAuditParameter(*this);
4879 }
4880
4881
4882
4883 #ifndef PASN_NOPRINTON
4884 const static PASN_Names Names_H248_IndAudMediaDescriptor_streams[]={
4885       {"oneStream",0}
4886      ,{"multiStream",1}
4887 };
4888 #endif
4889 //
4890 // IndAudMediaDescriptor_streams
4891 //
4892
4893 H248_IndAudMediaDescriptor_streams::H248_IndAudMediaDescriptor_streams(unsigned tag, PASN_Object::TagClass tagClass)
4894   : PASN_Choice(tag, tagClass, 2, FALSE
4895 #ifndef PASN_NOPRINTON
4896     ,(const PASN_Names *)Names_H248_IndAudMediaDescriptor_streams,2
4897 #endif
4898 )
4899 {
4900 }
4901
4902
4903 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4904 H248_IndAudMediaDescriptor_streams::operator H248_IndAudStreamParms &() const
4905 #else
4906 H248_IndAudMediaDescriptor_streams::operator H248_IndAudStreamParms &()
4907 {
4908 #ifndef PASN_LEANANDMEAN
4909   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudStreamParms), PInvalidCast);
4910 #endif
4911   return *(H248_IndAudStreamParms *)choice;
4912 }
4913
4914
4915 H248_IndAudMediaDescriptor_streams::operator const H248_IndAudStreamParms &() const
4916 #endif
4917 {
4918 #ifndef PASN_LEANANDMEAN
4919   PAssert(PIsDescendant(PAssertNULL(choice), H248_IndAudStreamParms), PInvalidCast);
4920 #endif
4921   return *(H248_IndAudStreamParms *)choice;
4922 }
4923
4924
4925 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4926 H248_IndAudMediaDescriptor_streams::operator H248_ArrayOf_IndAudStreamDescriptor &() const
4927 #else
4928 H248_IndAudMediaDescriptor_streams::operator H248_ArrayOf_IndAudStreamDescriptor &()
4929 {
4930 #ifndef PASN_LEANANDMEAN
4931   PAssert(PIsDescendant(PAssertNULL(choice), H248_ArrayOf_IndAudStreamDescriptor), PInvalidCast);
4932 #endif
4933   return *(H248_ArrayOf_IndAudStreamDescriptor *)choice;
4934 }
4935
4936
4937 H248_IndAudMediaDescriptor_streams::operator const H248_ArrayOf_IndAudStreamDescriptor &() const
4938 #endif
4939 {
4940 #ifndef PASN_LEANANDMEAN
4941   PAssert(PIsDescendant(PAssertNULL(choice), H248_ArrayOf_IndAudStreamDescriptor), PInvalidCast);
4942 #endif
4943   return *(H248_ArrayOf_IndAudStreamDescriptor *)choice;
4944 }
4945
4946
4947 BOOL H248_IndAudMediaDescriptor_streams::CreateObject()
4948 {
4949   switch (tag) {
4950     case e_oneStream :
4951       choice = new H248_IndAudStreamParms();
4952       return TRUE;
4953     case e_multiStream :
4954       choice = new H248_ArrayOf_IndAudStreamDescriptor();
4955       return TRUE;
4956   }
4957
4958   choice = NULL;
4959   return FALSE;
4960 }
4961
4962
4963 PObject * H248_IndAudMediaDescriptor_streams::Clone() const
4964 {
4965 #ifndef PASN_LEANANDMEAN
4966   PAssert(IsClass(H248_IndAudMediaDescriptor_streams::Class()), PInvalidCast);
4967 #endif
4968   return new H248_IndAudMediaDescriptor_streams(*this);
4969 }
4970
4971
4972 //
4973 // ArrayOf_IndAudPropertyParm
4974 //
4975
4976 H248_ArrayOf_IndAudPropertyParm::H248_ArrayOf_IndAudPropertyParm(unsigned tag, PASN_Object::TagClass tagClass)
4977   : PASN_Array(tag, tagClass)
4978 {
4979 }
4980
4981
4982 PASN_Object * H248_ArrayOf_IndAudPropertyParm::CreateObject() const
4983 {
4984   return new H248_IndAudPropertyParm;
4985 }
4986
4987
4988 H248_IndAudPropertyParm & H248_ArrayOf_IndAudPropertyParm::operator[](PINDEX i) const
4989 {
4990   return (H248_IndAudPropertyParm &)array[i];
4991 }
4992
4993
4994 PObject * H248_ArrayOf_IndAudPropertyParm::Clone() const
4995 {
4996 #ifndef PASN_LEANANDMEAN
4997   PAssert(IsClass(H248_ArrayOf_IndAudPropertyParm::Class()), PInvalidCast);
4998 #endif
4999   return new H248_ArrayOf_IndAudPropertyParm(*this);
5000 }
5001
5002
5003 //
5004 // ArrayOf_ObservedEvent
5005 //
5006
5007 H248_ArrayOf_ObservedEvent::H248_ArrayOf_ObservedEvent(unsigned tag, PASN_Object::TagClass tagClass)
5008   : PASN_Array(tag, tagClass)
5009 {
5010 }
5011
5012
5013 PASN_Object * H248_ArrayOf_ObservedEvent::CreateObject() const
5014 {
5015   return new H248_ObservedEvent;
5016 }
5017
5018
5019 H248_ObservedEvent & H248_ArrayOf_ObservedEvent::operator[](PINDEX i) const
5020 {
5021   return (H248_ObservedEvent &)array[i];
5022 }
5023
5024
5025 PObject * H248_ArrayOf_ObservedEvent::Clone() const
5026 {
5027 #ifndef PASN_LEANANDMEAN
5028   PAssert(IsClass(H248_ArrayOf_ObservedEvent::Class()), PInvalidCast);
5029 #endif
5030   return new H248_ArrayOf_ObservedEvent(*this);
5031 }
5032
5033
5034 //
5035 // ArrayOf_EventParameter
5036 //
5037
5038 H248_ArrayOf_EventParameter::H248_ArrayOf_EventParameter(unsigned tag, PASN_Object::TagClass tagClass)
5039   : PASN_Array(tag, tagClass)
5040 {
5041 }
5042
5043
5044 PASN_Object * H248_ArrayOf_EventParameter::CreateObject() const
5045 {
5046   return new H248_EventParameter;
5047 }
5048
5049
5050 H248_EventParameter & H248_ArrayOf_EventParameter::operator[](PINDEX i) const
5051 {
5052   return (H248_EventParameter &)array[i];
5053 }
5054
5055
5056 PObject * H248_ArrayOf_EventParameter::Clone() const
5057 {
5058 #ifndef PASN_LEANANDMEAN
5059   PAssert(IsClass(H248_ArrayOf_EventParameter::Class()), PInvalidCast);
5060 #endif
5061   return new H248_ArrayOf_EventParameter(*this);
5062 }
5063
5064
5065
5066 #ifndef PASN_NOPRINTON
5067 const static PASN_Names Names_H248_EventParameter_extraInfo[]={
5068       {"relation",0}
5069      ,{"range",1}
5070      ,{"sublist",2}
5071 };
5072 #endif
5073 //
5074 // EventParameter_extraInfo
5075 //
5076
5077 H248_EventParameter_extraInfo::H248_EventParameter_extraInfo(unsigned tag, PASN_Object::TagClass tagClass)
5078   : PASN_Choice(tag, tagClass, 3, FALSE
5079 #ifndef PASN_NOPRINTON
5080     ,(const PASN_Names *)Names_H248_EventParameter_extraInfo,3
5081 #endif
5082 )
5083 {
5084 }
5085
5086
5087 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5088 H248_EventParameter_extraInfo::operator H248_Relation &() const
5089 #else
5090 H248_EventParameter_extraInfo::operator H248_Relation &()
5091 {
5092 #ifndef PASN_LEANANDMEAN
5093   PAssert(PIsDescendant(PAssertNULL(choice), H248_Relation), PInvalidCast);
5094 #endif
5095   return *(H248_Relation *)choice;
5096 }
5097
5098
5099 H248_EventParameter_extraInfo::operator const H248_Relation &() const
5100 #endif
5101 {
5102 #ifndef PASN_LEANANDMEAN
5103   PAssert(PIsDescendant(PAssertNULL(choice), H248_Relation), PInvalidCast);
5104 #endif
5105   return *(H248_Relation *)choice;
5106 }
5107
5108
5109 BOOL H248_EventParameter_extraInfo::CreateObject()
5110 {
5111   switch (tag) {
5112     case e_relation :
5113       choice = new H248_Relation();
5114       return TRUE;
5115     case e_range :
5116     case e_sublist :
5117       choice = new PASN_Boolean();
5118       return TRUE;
5119   }
5120
5121   choice = NULL;
5122   return FALSE;
5123 }
5124
5125
5126 PObject * H248_EventParameter_extraInfo::Clone() const
5127 {
5128 #ifndef PASN_LEANANDMEAN
5129   PAssert(IsClass(H248_EventParameter_extraInfo::Class()), PInvalidCast);
5130 #endif
5131   return new H248_EventParameter_extraInfo(*this);
5132 }
5133
5134
5135 //
5136 // ArrayOf_WildcardField
5137 //
5138
5139 H248_ArrayOf_WildcardField::H248_ArrayOf_WildcardField(unsigned tag, PASN_Object::TagClass tagClass)
5140   : PASN_Array(tag, tagClass)
5141 {
5142 }
5143
5144
5145 PASN_Object * H248_ArrayOf_WildcardField::CreateObject() const
5146 {
5147   return new H248_WildcardField;
5148 }
5149
5150
5151 H248_WildcardField & H248_ArrayOf_WildcardField::operator[](PINDEX i) const
5152 {
5153   return (H248_WildcardField &)array[i];
5154 }
5155
5156
5157 PObject * H248_ArrayOf_WildcardField::Clone() const
5158 {
5159 #ifndef PASN_LEANANDMEAN
5160   PAssert(IsClass(H248_ArrayOf_WildcardField::Class()), PInvalidCast);
5161 #endif
5162   return new H248_ArrayOf_WildcardField(*this);
5163 }
5164
5165
5166
5167 #ifndef PASN_NOPRINTON
5168 const static PASN_Names Names_H248_MediaDescriptor_streams[]={
5169       {"oneStream",0}
5170      ,{"multiStream",1}
5171 };
5172 #endif
5173 //
5174 // MediaDescriptor_streams
5175 //
5176
5177 H248_MediaDescriptor_streams::H248_MediaDescriptor_streams(unsigned tag, PASN_Object::TagClass tagClass)
5178   : PASN_Choice(tag, tagClass, 2, FALSE
5179 #ifndef PASN_NOPRINTON
5180     ,(const PASN_Names *)Names_H248_MediaDescriptor_streams,2
5181 #endif
5182 )
5183 {
5184 }
5185
5186
5187 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5188 H248_MediaDescriptor_streams::operator H248_StreamParms &() const
5189 #else
5190 H248_MediaDescriptor_streams::operator H248_StreamParms &()
5191 {
5192 #ifndef PASN_LEANANDMEAN
5193   PAssert(PIsDescendant(PAssertNULL(choice), H248_StreamParms), PInvalidCast);
5194 #endif
5195   return *(H248_StreamParms *)choice;
5196 }
5197
5198
5199 H248_MediaDescriptor_streams::operator const H248_StreamParms &() const
5200 #endif
5201 {
5202 #ifndef PASN_LEANANDMEAN
5203   PAssert(PIsDescendant(PAssertNULL(choice), H248_StreamParms), PInvalidCast);
5204 #endif
5205   return *(H248_StreamParms *)choice;
5206 }
5207
5208
5209 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5210 H248_MediaDescriptor_streams::operator H248_ArrayOf_StreamDescriptor &() const
5211 #else
5212 H248_MediaDescriptor_streams::operator H248_ArrayOf_StreamDescriptor &()
5213 {
5214 #ifndef PASN_LEANANDMEAN
5215   PAssert(PIsDescendant(PAssertNULL(choice), H248_ArrayOf_StreamDescriptor), PInvalidCast);
5216 #endif
5217   return *(H248_ArrayOf_StreamDescriptor *)choice;
5218 }
5219
5220
5221 H248_MediaDescriptor_streams::operator const H248_ArrayOf_StreamDescriptor &() const
5222 #endif
5223 {
5224 #ifndef PASN_LEANANDMEAN
5225   PAssert(PIsDescendant(PAssertNULL(choice), H248_ArrayOf_StreamDescriptor), PInvalidCast);
5226 #endif
5227   return *(H248_ArrayOf_StreamDescriptor *)choice;
5228 }
5229
5230
5231 BOOL H248_MediaDescriptor_streams::CreateObject()
5232 {
5233   switch (tag) {
5234     case e_oneStream :
5235       choice = new H248_StreamParms();
5236       return TRUE;
5237     case e_multiStream :
5238       choice = new H248_ArrayOf_StreamDescriptor();
5239       return TRUE;
5240   }
5241
5242   choice = NULL;
5243   return FALSE;
5244 }
5245
5246
5247 PObject * H248_MediaDescriptor_streams::Clone() const
5248 {
5249 #ifndef PASN_LEANANDMEAN
5250   PAssert(IsClass(H248_MediaDescriptor_streams::Class()), PInvalidCast);
5251 #endif
5252   return new H248_MediaDescriptor_streams(*this);
5253 }
5254
5255
5256 //
5257 // ArrayOf_PropertyParm
5258 //
5259
5260 H248_ArrayOf_PropertyParm::H248_ArrayOf_PropertyParm(unsigned tag, PASN_Object::TagClass tagClass)
5261   : PASN_Array(tag, tagClass)
5262 {
5263 }
5264
5265
5266 PASN_Object * H248_ArrayOf_PropertyParm::CreateObject() const
5267 {
5268   return new H248_PropertyParm;
5269 }
5270
5271
5272 H248_PropertyParm & H248_ArrayOf_PropertyParm::operator[](PINDEX i) const
5273 {
5274   return (H248_PropertyParm &)array[i];
5275 }
5276
5277
5278 PObject * H248_ArrayOf_PropertyParm::Clone() const
5279 {
5280 #ifndef PASN_LEANANDMEAN
5281   PAssert(IsClass(H248_ArrayOf_PropertyParm::Class()), PInvalidCast);
5282 #endif
5283   return new H248_ArrayOf_PropertyParm(*this);
5284 }
5285
5286
5287 //
5288 // ArrayOf_PASN_OctetString
5289 //
5290
5291 H248_ArrayOf_PASN_OctetString::H248_ArrayOf_PASN_OctetString(unsigned tag, PASN_Object::TagClass tagClass)
5292   : PASN_Array(tag, tagClass)
5293 {
5294 }
5295
5296
5297 PASN_Object * H248_ArrayOf_PASN_OctetString::CreateObject() const
5298 {
5299   return new PASN_OctetString;
5300 }
5301
5302
5303 PASN_OctetString & H248_ArrayOf_PASN_OctetString::operator[](PINDEX i) const
5304 {
5305   return (PASN_OctetString &)array[i];
5306 }
5307
5308
5309 PObject * H248_ArrayOf_PASN_OctetString::Clone() const
5310 {
5311 #ifndef PASN_LEANANDMEAN
5312   PAssert(IsClass(H248_ArrayOf_PASN_OctetString::Class()), PInvalidCast);
5313 #endif
5314   return new H248_ArrayOf_PASN_OctetString(*this);
5315 }
5316
5317
5318
5319 #ifndef PASN_NOPRINTON
5320 const static PASN_Names Names_H248_PropertyParm_extraInfo[]={
5321       {"relation",0}
5322      ,{"range",1}
5323      ,{"sublist",2}
5324 };
5325 #endif
5326 //
5327 // PropertyParm_extraInfo
5328 //
5329
5330 H248_PropertyParm_extraInfo::H248_PropertyParm_extraInfo(unsigned tag, PASN_Object::TagClass tagClass)
5331   : PASN_Choice(tag, tagClass, 3, FALSE
5332 #ifndef PASN_NOPRINTON
5333     ,(const PASN_Names *)Names_H248_PropertyParm_extraInfo,3
5334 #endif
5335 )
5336 {
5337 }
5338
5339
5340 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5341 H248_PropertyParm_extraInfo::operator H248_Relation &() const
5342 #else
5343 H248_PropertyParm_extraInfo::operator H248_Relation &()
5344 {
5345 #ifndef PASN_LEANANDMEAN
5346   PAssert(PIsDescendant(PAssertNULL(choice), H248_Relation), PInvalidCast);
5347 #endif
5348   return *(H248_Relation *)choice;
5349 }
5350
5351
5352 H248_PropertyParm_extraInfo::operator const H248_Relation &() const
5353 #endif
5354 {
5355 #ifndef PASN_LEANANDMEAN
5356   PAssert(PIsDescendant(PAssertNULL(choice), H248_Relation), PInvalidCast);
5357 #endif
5358   return *(H248_Relation *)choice;
5359 }
5360
5361
5362 BOOL H248_PropertyParm_extraInfo::CreateObject()
5363 {
5364   switch (tag) {
5365     case e_relation :
5366       choice = new H248_Relation();
5367       return TRUE;
5368     case e_range :
5369     case e_sublist :
5370       choice = new PASN_Boolean();
5371       return TRUE;
5372   }
5373
5374   choice = NULL;
5375   return FALSE;
5376 }
5377
5378
5379 PObject * H248_PropertyParm_extraInfo::Clone() const
5380 {
5381 #ifndef PASN_LEANANDMEAN
5382   PAssert(IsClass(H248_PropertyParm_extraInfo::Class()), PInvalidCast);
5383 #endif
5384   return new H248_PropertyParm_extraInfo(*this);
5385 }
5386
5387
5388 //
5389 // ArrayOf_PropertyGroup
5390 //
5391
5392 H248_ArrayOf_PropertyGroup::H248_ArrayOf_PropertyGroup(unsigned tag, PASN_Object::TagClass tagClass)
5393   : PASN_Array(tag, tagClass)
5394 {
5395 }
5396
5397
5398 PASN_Object * H248_ArrayOf_PropertyGroup::CreateObject() const
5399 {
5400   return new H248_PropertyGroup;
5401 }
5402
5403
5404 H248_PropertyGroup & H248_ArrayOf_PropertyGroup::operator[](PINDEX i) const
5405 {
5406   return (H248_PropertyGroup &)array[i];
5407 }
5408
5409
5410 PObject * H248_ArrayOf_PropertyGroup::Clone() const
5411 {
5412 #ifndef PASN_LEANANDMEAN
5413   PAssert(IsClass(H248_ArrayOf_PropertyGroup::Class()), PInvalidCast);
5414 #endif
5415   return new H248_ArrayOf_PropertyGroup(*this);
5416 }
5417
5418
5419 //
5420 // ArrayOf_TerminationID
5421 //
5422
5423 H248_ArrayOf_TerminationID::H248_ArrayOf_TerminationID(unsigned tag, PASN_Object::TagClass tagClass)
5424   : PASN_Array(tag, tagClass)
5425 {
5426 }
5427
5428
5429 PASN_Object * H248_ArrayOf_TerminationID::CreateObject() const
5430 {
5431   return new H248_TerminationID;
5432 }
5433
5434
5435 H248_TerminationID & H248_ArrayOf_TerminationID::operator[](PINDEX i) const
5436 {
5437   return (H248_TerminationID &)array[i];
5438 }
5439
5440
5441 PObject * H248_ArrayOf_TerminationID::Clone() const
5442 {
5443 #ifndef PASN_LEANANDMEAN
5444   PAssert(IsClass(H248_ArrayOf_TerminationID::Class()), PInvalidCast);
5445 #endif
5446   return new H248_ArrayOf_TerminationID(*this);
5447 }
5448
5449
5450 //
5451 // ArrayOf_RequestedEvent
5452 //
5453
5454 H248_ArrayOf_RequestedEvent::H248_ArrayOf_RequestedEvent(unsigned tag, PASN_Object::TagClass tagClass)
5455   : PASN_Array(tag, tagClass)
5456 {
5457 }
5458
5459
5460 PASN_Object * H248_ArrayOf_RequestedEvent::CreateObject() const
5461 {
5462   return new H248_RequestedEvent;
5463 }
5464
5465
5466 H248_RequestedEvent & H248_ArrayOf_RequestedEvent::operator[](PINDEX i) const
5467 {
5468   return (H248_RequestedEvent &)array[i];
5469 }
5470
5471
5472 PObject * H248_ArrayOf_RequestedEvent::Clone() const
5473 {
5474 #ifndef PASN_LEANANDMEAN
5475   PAssert(IsClass(H248_ArrayOf_RequestedEvent::Class()), PInvalidCast);
5476 #endif
5477   return new H248_ArrayOf_RequestedEvent(*this);
5478 }
5479
5480
5481 //
5482 // ArrayOf_SecondRequestedEvent
5483 //
5484
5485 H248_ArrayOf_SecondRequestedEvent::H248_ArrayOf_SecondRequestedEvent(unsigned tag, PASN_Object::TagClass tagClass)
5486   : PASN_Array(tag, tagClass)
5487 {
5488 }
5489
5490
5491 PASN_Object * H248_ArrayOf_SecondRequestedEvent::CreateObject() const
5492 {
5493   return new H248_SecondRequestedEvent;
5494 }
5495
5496
5497 H248_SecondRequestedEvent & H248_ArrayOf_SecondRequestedEvent::operator[](PINDEX i) const
5498 {
5499   return (H248_SecondRequestedEvent &)array[i];
5500 }
5501
5502
5503 PObject * H248_ArrayOf_SecondRequestedEvent::Clone() const
5504 {
5505 #ifndef PASN_LEANANDMEAN
5506   PAssert(IsClass(H248_ArrayOf_SecondRequestedEvent::Class()), PInvalidCast);
5507 #endif
5508   return new H248_ArrayOf_SecondRequestedEvent(*this);
5509 }
5510
5511
5512 //
5513 // ArrayOf_Signal
5514 //
5515
5516 H248_ArrayOf_Signal::H248_ArrayOf_Signal(unsigned tag, PASN_Object::TagClass tagClass)
5517   : PASN_Array(tag, tagClass)
5518 {
5519 }
5520
5521
5522 PASN_Object * H248_ArrayOf_Signal::CreateObject() const
5523 {
5524   return new H248_Signal;
5525 }
5526
5527
5528 H248_Signal & H248_ArrayOf_Signal::operator[](PINDEX i) const
5529 {
5530   return (H248_Signal &)array[i];
5531 }
5532
5533
5534 PObject * H248_ArrayOf_Signal::Clone() const
5535 {
5536 #ifndef PASN_LEANANDMEAN
5537   PAssert(IsClass(H248_ArrayOf_Signal::Class()), PInvalidCast);
5538 #endif
5539   return new H248_ArrayOf_Signal(*this);
5540 }
5541
5542
5543 //
5544 // ArrayOf_SigParameter
5545 //
5546
5547 H248_ArrayOf_SigParameter::H248_ArrayOf_SigParameter(unsigned tag, PASN_Object::TagClass tagClass)
5548   : PASN_Array(tag, tagClass)
5549 {
5550 }
5551
5552
5553 PASN_Object * H248_ArrayOf_SigParameter::CreateObject() const
5554 {
5555   return new H248_SigParameter;
5556 }
5557
5558
5559 H248_SigParameter & H248_ArrayOf_SigParameter::operator[](PINDEX i) const
5560 {
5561   return (H248_SigParameter &)array[i];
5562 }
5563
5564
5565 PObject * H248_ArrayOf_SigParameter::Clone() const
5566 {
5567 #ifndef PASN_LEANANDMEAN
5568   PAssert(IsClass(H248_ArrayOf_SigParameter::Class()), PInvalidCast);
5569 #endif
5570   return new H248_ArrayOf_SigParameter(*this);
5571 }
5572
5573
5574
5575 #ifndef PASN_NOPRINTON
5576 const static PASN_Names Names_H248_SigParameter_extraInfo[]={
5577       {"relation",0}
5578      ,{"range",1}
5579      ,{"sublist",2}
5580 };
5581 #endif
5582 //
5583 // SigParameter_extraInfo
5584 //
5585
5586 H248_SigParameter_extraInfo::H248_SigParameter_extraInfo(unsigned tag, PASN_Object::TagClass tagClass)
5587   : PASN_Choice(tag, tagClass, 3, FALSE
5588 #ifndef PASN_NOPRINTON
5589     ,(const PASN_Names *)Names_H248_SigParameter_extraInfo,3
5590 #endif
5591 )
5592 {
5593 }
5594
5595
5596 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5597 H248_SigParameter_extraInfo::operator H248_Relation &() const
5598 #else
5599 H248_SigParameter_extraInfo::operator H248_Relation &()
5600 {
5601 #ifndef PASN_LEANANDMEAN
5602   PAssert(PIsDescendant(PAssertNULL(choice), H248_Relation), PInvalidCast);
5603 #endif
5604   return *(H248_Relation *)choice;
5605 }
5606
5607
5608 H248_SigParameter_extraInfo::operator const H248_Relation &() const
5609 #endif
5610 {
5611 #ifndef PASN_LEANANDMEAN
5612   PAssert(PIsDescendant(PAssertNULL(choice), H248_Relation), PInvalidCast);
5613 #endif
5614   return *(H248_Relation *)choice;
5615 }
5616
5617
5618 BOOL H248_SigParameter_extraInfo::CreateObject()
5619 {
5620   switch (tag) {
5621     case e_relation :
5622       choice = new H248_Relation();
5623       return TRUE;
5624     case e_range :
5625     case e_sublist :
5626       choice = new PASN_Boolean();
5627       return TRUE;
5628   }
5629
5630   choice = NULL;
5631   return FALSE;
5632 }
5633
5634
5635 PObject * H248_SigParameter_extraInfo::Clone() const
5636 {
5637 #ifndef PASN_LEANANDMEAN
5638   PAssert(IsClass(H248_SigParameter_extraInfo::Class()), PInvalidCast);
5639 #endif
5640   return new H248_SigParameter_extraInfo(*this);
5641 }
5642
5643
5644 //
5645 // ArrayOf_ModemType
5646 //
5647
5648 H248_ArrayOf_ModemType::H248_ArrayOf_ModemType(unsigned tag, PASN_Object::TagClass tagClass)
5649   : PASN_Array(tag, tagClass)
5650 {
5651 }
5652
5653
5654 PASN_Object * H248_ArrayOf_ModemType::CreateObject() const
5655 {
5656   return new H248_ModemType;
5657 }
5658
5659
5660 H248_ModemType & H248_ArrayOf_ModemType::operator[](PINDEX i) const
5661 {
5662   return (H248_ModemType &)array[i];
5663 }
5664
5665
5666 PObject * H248_ArrayOf_ModemType::Clone() const
5667 {
5668 #ifndef PASN_LEANANDMEAN
5669   PAssert(IsClass(H248_ArrayOf_ModemType::Class()), PInvalidCast);
5670 #endif
5671   return new H248_ArrayOf_ModemType(*this);
5672 }
5673
5674
5675 //
5676 // ArrayOf_Transaction
5677 //
5678
5679 H248_ArrayOf_Transaction::H248_ArrayOf_Transaction(unsigned tag, PASN_Object::TagClass tagClass)
5680   : PASN_Array(tag, tagClass)
5681 {
5682 }
5683
5684
5685 PASN_Object * H248_ArrayOf_Transaction::CreateObject() const
5686 {
5687   return new H248_Transaction;
5688 }
5689
5690
5691 H248_Transaction & H248_ArrayOf_Transaction::operator[](PINDEX i) const
5692 {
5693   return (H248_Transaction &)array[i];
5694 }
5695
5696
5697 PObject * H248_ArrayOf_Transaction::Clone() const
5698 {
5699 #ifndef PASN_LEANANDMEAN
5700   PAssert(IsClass(H248_ArrayOf_Transaction::Class()), PInvalidCast);
5701 #endif
5702   return new H248_ArrayOf_Transaction(*this);
5703 }
5704
5705
5706 //
5707 // ArrayOf_ActionReply
5708 //
5709
5710 H248_ArrayOf_ActionReply::H248_ArrayOf_ActionReply(unsigned tag, PASN_Object::TagClass tagClass)
5711   : PASN_Array(tag, tagClass)
5712 {
5713 }
5714
5715
5716 PASN_Object * H248_ArrayOf_ActionReply::CreateObject() const
5717 {
5718   return new H248_ActionReply;
5719 }
5720
5721
5722 H248_ActionReply & H248_ArrayOf_ActionReply::operator[](PINDEX i) const
5723 {
5724   return (H248_ActionReply &)array[i];
5725 }
5726
5727
5728 PObject * H248_ArrayOf_ActionReply::Clone() const
5729 {
5730 #ifndef PASN_LEANANDMEAN
5731   PAssert(IsClass(H248_ArrayOf_ActionReply::Class()), PInvalidCast);
5732 #endif
5733   return new H248_ArrayOf_ActionReply(*this);
5734 }
5735
5736
5737 //
5738 // ArrayOf_IndAudStreamDescriptor
5739 //
5740
5741 H248_ArrayOf_IndAudStreamDescriptor::H248_ArrayOf_IndAudStreamDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
5742   : PASN_Array(tag, tagClass)
5743 {
5744 }
5745
5746
5747 PASN_Object * H248_ArrayOf_IndAudStreamDescriptor::CreateObject() const
5748 {
5749   return new H248_IndAudStreamDescriptor;
5750 }
5751
5752
5753 H248_IndAudStreamDescriptor & H248_ArrayOf_IndAudStreamDescriptor::operator[](PINDEX i) const
5754 {
5755   return (H248_IndAudStreamDescriptor &)array[i];
5756 }
5757
5758
5759 PObject * H248_ArrayOf_IndAudStreamDescriptor::Clone() const
5760 {
5761 #ifndef PASN_LEANANDMEAN
5762   PAssert(IsClass(H248_ArrayOf_IndAudStreamDescriptor::Class()), PInvalidCast);
5763 #endif
5764   return new H248_ArrayOf_IndAudStreamDescriptor(*this);
5765 }
5766
5767
5768 //
5769 // ArrayOf_StreamDescriptor
5770 //
5771
5772 H248_ArrayOf_StreamDescriptor::H248_ArrayOf_StreamDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
5773   : PASN_Array(tag, tagClass)
5774 {
5775 }
5776
5777
5778 PASN_Object * H248_ArrayOf_StreamDescriptor::CreateObject() const
5779 {
5780   return new H248_StreamDescriptor;
5781 }
5782
5783
5784 H248_StreamDescriptor & H248_ArrayOf_StreamDescriptor::operator[](PINDEX i) const
5785 {
5786   return (H248_StreamDescriptor &)array[i];
5787 }
5788
5789
5790 PObject * H248_ArrayOf_StreamDescriptor::Clone() const
5791 {
5792 #ifndef PASN_LEANANDMEAN
5793   PAssert(IsClass(H248_ArrayOf_StreamDescriptor::Class()), PInvalidCast);
5794 #endif
5795   return new H248_ArrayOf_StreamDescriptor(*this);
5796 }
5797
5798
5799 //
5800 // AuthenticationHeader
5801 //
5802
5803 H248_AuthenticationHeader::H248_AuthenticationHeader(unsigned tag, PASN_Object::TagClass tagClass)
5804   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
5805 {
5806 }
5807
5808
5809 #ifndef PASN_NOPRINTON
5810 void H248_AuthenticationHeader::PrintOn(ostream & strm) const
5811 {
5812   int indent = strm.precision() + 2;
5813   strm << "{\n";
5814   strm << setw(indent+15) << "secParmIndex = " << setprecision(indent) << m_secParmIndex << '\n';
5815   strm << setw(indent+9) << "seqNum = " << setprecision(indent) << m_seqNum << '\n';
5816   strm << setw(indent+5) << "ad = " << setprecision(indent) << m_ad << '\n';
5817   strm << setw(indent-1) << setprecision(indent-2) << "}";
5818 }
5819 #endif
5820
5821
5822 PObject::Comparison H248_AuthenticationHeader::Compare(const PObject & obj) const
5823 {
5824 #ifndef PASN_LEANANDMEAN
5825   PAssert(PIsDescendant(&obj, H248_AuthenticationHeader), PInvalidCast);
5826 #endif
5827   const H248_AuthenticationHeader & other = (const H248_AuthenticationHeader &)obj;
5828
5829   Comparison result;
5830
5831   if ((result = m_secParmIndex.Compare(other.m_secParmIndex)) != EqualTo)
5832     return result;
5833   if ((result = m_seqNum.Compare(other.m_seqNum)) != EqualTo)
5834     return result;
5835   if ((result = m_ad.Compare(other.m_ad)) != EqualTo)
5836     return result;
5837
5838   return PASN_Sequence::Compare(other);
5839 }
5840
5841
5842 PINDEX H248_AuthenticationHeader::GetDataLength() const
5843 {
5844   PINDEX length = 0;
5845   length += m_secParmIndex.GetObjectLength();
5846   length += m_seqNum.GetObjectLength();
5847   length += m_ad.GetObjectLength();
5848   return length;
5849 }
5850
5851
5852 BOOL H248_AuthenticationHeader::Decode(PASN_Stream & strm)
5853 {
5854   if (!PreambleDecode(strm))
5855     return FALSE;
5856
5857   if (!m_secParmIndex.Decode(strm))
5858     return FALSE;
5859   if (!m_seqNum.Decode(strm))
5860     return FALSE;
5861   if (!m_ad.Decode(strm))
5862     return FALSE;
5863
5864   return UnknownExtensionsDecode(strm);
5865 }
5866
5867
5868 void H248_AuthenticationHeader::Encode(PASN_Stream & strm) const
5869 {
5870   PreambleEncode(strm);
5871
5872   m_secParmIndex.Encode(strm);
5873   m_seqNum.Encode(strm);
5874   m_ad.Encode(strm);
5875
5876   UnknownExtensionsEncode(strm);
5877 }
5878
5879
5880 PObject * H248_AuthenticationHeader::Clone() const
5881 {
5882 #ifndef PASN_LEANANDMEAN
5883   PAssert(IsClass(H248_AuthenticationHeader::Class()), PInvalidCast);
5884 #endif
5885   return new H248_AuthenticationHeader(*this);
5886 }
5887
5888
5889 //
5890 // Message
5891 //
5892
5893 H248_Message::H248_Message(unsigned tag, PASN_Object::TagClass tagClass)
5894   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
5895 {
5896   m_version.SetConstraints(PASN_Object::FixedConstraint, 0, 99);
5897 }
5898
5899
5900 #ifndef PASN_NOPRINTON
5901 void H248_Message::PrintOn(ostream & strm) const
5902 {
5903   int indent = strm.precision() + 2;
5904   strm << "{\n";
5905   strm << setw(indent+10) << "version = " << setprecision(indent) << m_version << '\n';
5906   strm << setw(indent+6) << "mId = " << setprecision(indent) << m_mId << '\n';
5907   strm << setw(indent+14) << "messageBody = " << setprecision(indent) << m_messageBody << '\n';
5908   strm << setw(indent-1) << setprecision(indent-2) << "}";
5909 }
5910 #endif
5911
5912
5913 PObject::Comparison H248_Message::Compare(const PObject & obj) const
5914 {
5915 #ifndef PASN_LEANANDMEAN
5916   PAssert(PIsDescendant(&obj, H248_Message), PInvalidCast);
5917 #endif
5918   const H248_Message & other = (const H248_Message &)obj;
5919
5920   Comparison result;
5921
5922   if ((result = m_version.Compare(other.m_version)) != EqualTo)
5923     return result;
5924   if ((result = m_mId.Compare(other.m_mId)) != EqualTo)
5925     return result;
5926   if ((result = m_messageBody.Compare(other.m_messageBody)) != EqualTo)
5927     return result;
5928
5929   return PASN_Sequence::Compare(other);
5930 }
5931
5932
5933 PINDEX H248_Message::GetDataLength() const
5934 {
5935   PINDEX length = 0;
5936   length += m_version.GetObjectLength();
5937   length += m_mId.GetObjectLength();
5938   length += m_messageBody.GetObjectLength();
5939   return length;
5940 }
5941
5942
5943 BOOL H248_Message::Decode(PASN_Stream & strm)
5944 {
5945   if (!PreambleDecode(strm))
5946     return FALSE;
5947
5948   if (!m_version.Decode(strm))
5949     return FALSE;
5950   if (!m_mId.Decode(strm))
5951     return FALSE;
5952   if (!m_messageBody.Decode(strm))
5953     return FALSE;
5954
5955   return UnknownExtensionsDecode(strm);
5956 }
5957
5958
5959 void H248_Message::Encode(PASN_Stream & strm) const
5960 {
5961   PreambleEncode(strm);
5962
5963   m_version.Encode(strm);
5964   m_mId.Encode(strm);
5965   m_messageBody.Encode(strm);
5966
5967   UnknownExtensionsEncode(strm);
5968 }
5969
5970
5971 PObject * H248_Message::Clone() const
5972 {
5973 #ifndef PASN_LEANANDMEAN
5974   PAssert(IsClass(H248_Message::Class()), PInvalidCast);
5975 #endif
5976   return new H248_Message(*this);
5977 }
5978
5979
5980 //
5981 // TransactionRequest
5982 //
5983
5984 H248_TransactionRequest::H248_TransactionRequest(unsigned tag, PASN_Object::TagClass tagClass)
5985   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
5986 {
5987 }
5988
5989
5990 #ifndef PASN_NOPRINTON
5991 void H248_TransactionRequest::PrintOn(ostream & strm) const
5992 {
5993   int indent = strm.precision() + 2;
5994   strm << "{\n";
5995   strm << setw(indent+16) << "transactionId = " << setprecision(indent) << m_transactionId << '\n';
5996   strm << setw(indent+10) << "actions = " << setprecision(indent) << m_actions << '\n';
5997   strm << setw(indent-1) << setprecision(indent-2) << "}";
5998 }
5999 #endif
6000
6001
6002 PObject::Comparison H248_TransactionRequest::Compare(const PObject & obj) const
6003 {
6004 #ifndef PASN_LEANANDMEAN
6005   PAssert(PIsDescendant(&obj, H248_TransactionRequest), PInvalidCast);
6006 #endif
6007   const H248_TransactionRequest & other = (const H248_TransactionRequest &)obj;
6008
6009   Comparison result;
6010
6011   if ((result = m_transactionId.Compare(other.m_transactionId)) != EqualTo)
6012     return result;
6013   if ((result = m_actions.Compare(other.m_actions)) != EqualTo)
6014     return result;
6015
6016   return PASN_Sequence::Compare(other);
6017 }
6018
6019
6020 PINDEX H248_TransactionRequest::GetDataLength() const
6021 {
6022   PINDEX length = 0;
6023   length += m_transactionId.GetObjectLength();
6024   length += m_actions.GetObjectLength();
6025   return length;
6026 }
6027
6028
6029 BOOL H248_TransactionRequest::Decode(PASN_Stream & strm)
6030 {
6031   if (!PreambleDecode(strm))
6032     return FALSE;
6033
6034   if (!m_transactionId.Decode(strm))
6035     return FALSE;
6036   if (!m_actions.Decode(strm))
6037     return FALSE;
6038
6039   return UnknownExtensionsDecode(strm);
6040 }
6041
6042
6043 void H248_TransactionRequest::Encode(PASN_Stream & strm) const
6044 {
6045   PreambleEncode(strm);
6046
6047   m_transactionId.Encode(strm);
6048   m_actions.Encode(strm);
6049
6050   UnknownExtensionsEncode(strm);
6051 }
6052
6053
6054 PObject * H248_TransactionRequest::Clone() const
6055 {
6056 #ifndef PASN_LEANANDMEAN
6057   PAssert(IsClass(H248_TransactionRequest::Class()), PInvalidCast);
6058 #endif
6059   return new H248_TransactionRequest(*this);
6060 }
6061
6062
6063 //
6064 // TransactionReply
6065 //
6066
6067 H248_TransactionReply::H248_TransactionReply(unsigned tag, PASN_Object::TagClass tagClass)
6068   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
6069 {
6070 }
6071
6072
6073 #ifndef PASN_NOPRINTON
6074 void H248_TransactionReply::PrintOn(ostream & strm) const
6075 {
6076   int indent = strm.precision() + 2;
6077   strm << "{\n";
6078   strm << setw(indent+16) << "transactionId = " << setprecision(indent) << m_transactionId << '\n';
6079   if (HasOptionalField(e_immAckRequired))
6080     strm << setw(indent+17) << "immAckRequired = " << setprecision(indent) << m_immAckRequired << '\n';
6081   strm << setw(indent+20) << "transactionResult = " << setprecision(indent) << m_transactionResult << '\n';
6082   strm << setw(indent-1) << setprecision(indent-2) << "}";
6083 }
6084 #endif
6085
6086
6087 PObject::Comparison H248_TransactionReply::Compare(const PObject & obj) const
6088 {
6089 #ifndef PASN_LEANANDMEAN
6090   PAssert(PIsDescendant(&obj, H248_TransactionReply), PInvalidCast);
6091 #endif
6092   const H248_TransactionReply & other = (const H248_TransactionReply &)obj;
6093
6094   Comparison result;
6095
6096   if ((result = m_transactionId.Compare(other.m_transactionId)) != EqualTo)
6097     return result;
6098   if ((result = m_immAckRequired.Compare(other.m_immAckRequired)) != EqualTo)
6099     return result;
6100   if ((result = m_transactionResult.Compare(other.m_transactionResult)) != EqualTo)
6101     return result;
6102
6103   return PASN_Sequence::Compare(other);
6104 }
6105
6106
6107 PINDEX H248_TransactionReply::GetDataLength() const
6108 {
6109   PINDEX length = 0;
6110   length += m_transactionId.GetObjectLength();
6111   if (HasOptionalField(e_immAckRequired))
6112     length += m_immAckRequired.GetObjectLength();
6113   length += m_transactionResult.GetObjectLength();
6114   return length;
6115 }
6116
6117
6118 BOOL H248_TransactionReply::Decode(PASN_Stream & strm)
6119 {
6120   if (!PreambleDecode(strm))
6121     return FALSE;
6122
6123   if (!m_transactionId.Decode(strm))
6124     return FALSE;
6125   if (HasOptionalField(e_immAckRequired) && !m_immAckRequired.Decode(strm))
6126     return FALSE;
6127   if (!m_transactionResult.Decode(strm))
6128     return FALSE;
6129
6130   return UnknownExtensionsDecode(strm);
6131 }
6132
6133
6134 void H248_TransactionReply::Encode(PASN_Stream & strm) const
6135 {
6136   PreambleEncode(strm);
6137
6138   m_transactionId.Encode(strm);
6139   if (HasOptionalField(e_immAckRequired))
6140     m_immAckRequired.Encode(strm);
6141   m_transactionResult.Encode(strm);
6142
6143   UnknownExtensionsEncode(strm);
6144 }
6145
6146
6147 PObject * H248_TransactionReply::Clone() const
6148 {
6149 #ifndef PASN_LEANANDMEAN
6150   PAssert(IsClass(H248_TransactionReply::Class()), PInvalidCast);
6151 #endif
6152   return new H248_TransactionReply(*this);
6153 }
6154
6155
6156 //
6157 // ErrorDescriptor
6158 //
6159
6160 H248_ErrorDescriptor::H248_ErrorDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
6161   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
6162 {
6163 }
6164
6165
6166 #ifndef PASN_NOPRINTON
6167 void H248_ErrorDescriptor::PrintOn(ostream & strm) const
6168 {
6169   int indent = strm.precision() + 2;
6170   strm << "{\n";
6171   strm << setw(indent+12) << "errorCode = " << setprecision(indent) << m_errorCode << '\n';
6172   if (HasOptionalField(e_errorText))
6173     strm << setw(indent+12) << "errorText = " << setprecision(indent) << m_errorText << '\n';
6174   strm << setw(indent-1) << setprecision(indent-2) << "}";
6175 }
6176 #endif
6177
6178
6179 PObject::Comparison H248_ErrorDescriptor::Compare(const PObject & obj) const
6180 {
6181 #ifndef PASN_LEANANDMEAN
6182   PAssert(PIsDescendant(&obj, H248_ErrorDescriptor), PInvalidCast);
6183 #endif
6184   const H248_ErrorDescriptor & other = (const H248_ErrorDescriptor &)obj;
6185
6186   Comparison result;
6187
6188   if ((result = m_errorCode.Compare(other.m_errorCode)) != EqualTo)
6189     return result;
6190   if ((result = m_errorText.Compare(other.m_errorText)) != EqualTo)
6191     return result;
6192
6193   return PASN_Sequence::Compare(other);
6194 }
6195
6196
6197 PINDEX H248_ErrorDescriptor::GetDataLength() const
6198 {
6199   PINDEX length = 0;
6200   length += m_errorCode.GetObjectLength();
6201   if (HasOptionalField(e_errorText))
6202     length += m_errorText.GetObjectLength();
6203   return length;
6204 }
6205
6206
6207 BOOL H248_ErrorDescriptor::Decode(PASN_Stream & strm)
6208 {
6209   if (!PreambleDecode(strm))
6210     return FALSE;
6211
6212   if (!m_errorCode.Decode(strm))
6213     return FALSE;
6214   if (HasOptionalField(e_errorText) && !m_errorText.Decode(strm))
6215     return FALSE;
6216
6217   return UnknownExtensionsDecode(strm);
6218 }
6219
6220
6221 void H248_ErrorDescriptor::Encode(PASN_Stream & strm) const
6222 {
6223   PreambleEncode(strm);
6224
6225   m_errorCode.Encode(strm);
6226   if (HasOptionalField(e_errorText))
6227     m_errorText.Encode(strm);
6228
6229   UnknownExtensionsEncode(strm);
6230 }
6231
6232
6233 PObject * H248_ErrorDescriptor::Clone() const
6234 {
6235 #ifndef PASN_LEANANDMEAN
6236   PAssert(IsClass(H248_ErrorDescriptor::Class()), PInvalidCast);
6237 #endif
6238   return new H248_ErrorDescriptor(*this);
6239 }
6240
6241
6242 //
6243 // ContextRequest
6244 //
6245
6246 H248_ContextRequest::H248_ContextRequest(unsigned tag, PASN_Object::TagClass tagClass)
6247   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
6248 {
6249   m_priority.SetConstraints(PASN_Object::FixedConstraint, 0, 15);
6250 }
6251
6252
6253 #ifndef PASN_NOPRINTON
6254 void H248_ContextRequest::PrintOn(ostream & strm) const
6255 {
6256   int indent = strm.precision() + 2;
6257   strm << "{\n";
6258   if (HasOptionalField(e_priority))
6259     strm << setw(indent+11) << "priority = " << setprecision(indent) << m_priority << '\n';
6260   if (HasOptionalField(e_emergency))
6261     strm << setw(indent+12) << "emergency = " << setprecision(indent) << m_emergency << '\n';
6262   if (HasOptionalField(e_topologyReq))
6263     strm << setw(indent+14) << "topologyReq = " << setprecision(indent) << m_topologyReq << '\n';
6264   strm << setw(indent-1) << setprecision(indent-2) << "}";
6265 }
6266 #endif
6267
6268
6269 PObject::Comparison H248_ContextRequest::Compare(const PObject & obj) const
6270 {
6271 #ifndef PASN_LEANANDMEAN
6272   PAssert(PIsDescendant(&obj, H248_ContextRequest), PInvalidCast);
6273 #endif
6274   const H248_ContextRequest & other = (const H248_ContextRequest &)obj;
6275
6276   Comparison result;
6277
6278   if ((result = m_priority.Compare(other.m_priority)) != EqualTo)
6279     return result;
6280   if ((result = m_emergency.Compare(other.m_emergency)) != EqualTo)
6281     return result;
6282   if ((result = m_topologyReq.Compare(other.m_topologyReq)) != EqualTo)
6283     return result;
6284
6285   return PASN_Sequence::Compare(other);
6286 }
6287
6288
6289 PINDEX H248_ContextRequest::GetDataLength() const
6290 {
6291   PINDEX length = 0;
6292   if (HasOptionalField(e_priority))
6293     length += m_priority.GetObjectLength();
6294   if (HasOptionalField(e_emergency))
6295     length += m_emergency.GetObjectLength();
6296   if (HasOptionalField(e_topologyReq))
6297     length += m_topologyReq.GetObjectLength();
6298   return length;
6299 }
6300
6301
6302 BOOL H248_ContextRequest::Decode(PASN_Stream & strm)
6303 {
6304   if (!PreambleDecode(strm))
6305     return FALSE;
6306
6307   if (HasOptionalField(e_priority) && !m_priority.Decode(strm))
6308     return FALSE;
6309   if (HasOptionalField(e_emergency) && !m_emergency.Decode(strm))
6310     return FALSE;
6311   if (HasOptionalField(e_topologyReq) && !m_topologyReq.Decode(strm))
6312     return FALSE;
6313
6314   return UnknownExtensionsDecode(strm);
6315 }
6316
6317
6318 void H248_ContextRequest::Encode(PASN_Stream & strm) const
6319 {
6320   PreambleEncode(strm);
6321
6322   if (HasOptionalField(e_priority))
6323     m_priority.Encode(strm);
6324   if (HasOptionalField(e_emergency))
6325     m_emergency.Encode(strm);
6326   if (HasOptionalField(e_topologyReq))
6327     m_topologyReq.Encode(strm);
6328
6329   UnknownExtensionsEncode(strm);
6330 }
6331
6332
6333 PObject * H248_ContextRequest::Clone() const
6334 {
6335 #ifndef PASN_LEANANDMEAN
6336   PAssert(IsClass(H248_ContextRequest::Class()), PInvalidCast);
6337 #endif
6338   return new H248_ContextRequest(*this);
6339 }
6340
6341
6342 //
6343 // CommandRequest
6344 //
6345
6346 H248_CommandRequest::H248_CommandRequest(unsigned tag, PASN_Object::TagClass tagClass)
6347   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
6348 {
6349 }
6350
6351
6352 #ifndef PASN_NOPRINTON
6353 void H248_CommandRequest::PrintOn(ostream & strm) const
6354 {
6355   int indent = strm.precision() + 2;
6356   strm << "{\n";
6357   strm << setw(indent+10) << "command = " << setprecision(indent) << m_command << '\n';
6358   if (HasOptionalField(e_optional))
6359     strm << setw(indent+11) << "optional = " << setprecision(indent) << m_optional << '\n';
6360   if (HasOptionalField(e_wildcardReturn))
6361     strm << setw(indent+17) << "wildcardReturn = " << setprecision(indent) << m_wildcardReturn << '\n';
6362   strm << setw(indent-1) << setprecision(indent-2) << "}";
6363 }
6364 #endif
6365
6366
6367 PObject::Comparison H248_CommandRequest::Compare(const PObject & obj) const
6368 {
6369 #ifndef PASN_LEANANDMEAN
6370   PAssert(PIsDescendant(&obj, H248_CommandRequest), PInvalidCast);
6371 #endif
6372   const H248_CommandRequest & other = (const H248_CommandRequest &)obj;
6373
6374   Comparison result;
6375
6376   if ((result = m_command.Compare(other.m_command)) != EqualTo)
6377     return result;
6378   if ((result = m_optional.Compare(other.m_optional)) != EqualTo)
6379     return result;
6380   if ((result = m_wildcardReturn.Compare(other.m_wildcardReturn)) != EqualTo)
6381     return result;
6382
6383   return PASN_Sequence::Compare(other);
6384 }
6385
6386
6387 PINDEX H248_CommandRequest::GetDataLength() const
6388 {
6389   PINDEX length = 0;
6390   length += m_command.GetObjectLength();
6391   if (HasOptionalField(e_optional))
6392     length += m_optional.GetObjectLength();
6393   if (HasOptionalField(e_wildcardReturn))
6394     length += m_wildcardReturn.GetObjectLength();
6395   return length;
6396 }
6397
6398
6399 BOOL H248_CommandRequest::Decode(PASN_Stream & strm)
6400 {
6401   if (!PreambleDecode(strm))
6402     return FALSE;
6403
6404   if (!m_command.Decode(strm))
6405     return FALSE;
6406   if (HasOptionalField(e_optional) && !m_optional.Decode(strm))
6407     return FALSE;
6408   if (HasOptionalField(e_wildcardReturn) && !m_wildcardReturn.Decode(strm))
6409     return FALSE;
6410
6411   return UnknownExtensionsDecode(strm);
6412 }
6413
6414
6415 void H248_CommandRequest::Encode(PASN_Stream & strm) const
6416 {
6417   PreambleEncode(strm);
6418
6419   m_command.Encode(strm);
6420   if (HasOptionalField(e_optional))
6421     m_optional.Encode(strm);
6422   if (HasOptionalField(e_wildcardReturn))
6423     m_wildcardReturn.Encode(strm);
6424
6425   UnknownExtensionsEncode(strm);
6426 }
6427
6428
6429 PObject * H248_CommandRequest::Clone() const
6430 {
6431 #ifndef PASN_LEANANDMEAN
6432   PAssert(IsClass(H248_CommandRequest::Class()), PInvalidCast);
6433 #endif
6434   return new H248_CommandRequest(*this);
6435 }
6436
6437
6438 //
6439 // AmmRequest
6440 //
6441
6442 H248_AmmRequest::H248_AmmRequest(unsigned tag, PASN_Object::TagClass tagClass)
6443   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
6444 {
6445 }
6446
6447
6448 #ifndef PASN_NOPRINTON
6449 void H248_AmmRequest::PrintOn(ostream & strm) const
6450 {
6451   int indent = strm.precision() + 2;
6452   strm << "{\n";
6453   strm << setw(indent+16) << "terminationID = " << setprecision(indent) << m_terminationID << '\n';
6454   strm << setw(indent+14) << "descriptors = " << setprecision(indent) << m_descriptors << '\n';
6455   strm << setw(indent-1) << setprecision(indent-2) << "}";
6456 }
6457 #endif
6458
6459
6460 PObject::Comparison H248_AmmRequest::Compare(const PObject & obj) const
6461 {
6462 #ifndef PASN_LEANANDMEAN
6463   PAssert(PIsDescendant(&obj, H248_AmmRequest), PInvalidCast);
6464 #endif
6465   const H248_AmmRequest & other = (const H248_AmmRequest &)obj;
6466
6467   Comparison result;
6468
6469   if ((result = m_terminationID.Compare(other.m_terminationID)) != EqualTo)
6470     return result;
6471   if ((result = m_descriptors.Compare(other.m_descriptors)) != EqualTo)
6472     return result;
6473
6474   return PASN_Sequence::Compare(other);
6475 }
6476
6477
6478 PINDEX H248_AmmRequest::GetDataLength() const
6479 {
6480   PINDEX length = 0;
6481   length += m_terminationID.GetObjectLength();
6482   length += m_descriptors.GetObjectLength();
6483   return length;
6484 }
6485
6486
6487 BOOL H248_AmmRequest::Decode(PASN_Stream & strm)
6488 {
6489   if (!PreambleDecode(strm))
6490     return FALSE;
6491
6492   if (!m_terminationID.Decode(strm))
6493     return FALSE;
6494   if (!m_descriptors.Decode(strm))
6495     return FALSE;
6496
6497   return UnknownExtensionsDecode(strm);
6498 }
6499
6500
6501 void H248_AmmRequest::Encode(PASN_Stream & strm) const
6502 {
6503   PreambleEncode(strm);
6504
6505   m_terminationID.Encode(strm);
6506   m_descriptors.Encode(strm);
6507
6508   UnknownExtensionsEncode(strm);
6509 }
6510
6511
6512 PObject * H248_AmmRequest::Clone() const
6513 {
6514 #ifndef PASN_LEANANDMEAN
6515   PAssert(IsClass(H248_AmmRequest::Class()), PInvalidCast);
6516 #endif
6517   return new H248_AmmRequest(*this);
6518 }
6519
6520
6521 //
6522 // AmmsReply
6523 //
6524
6525 H248_AmmsReply::H248_AmmsReply(unsigned tag, PASN_Object::TagClass tagClass)
6526   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
6527 {
6528 }
6529
6530
6531 #ifndef PASN_NOPRINTON
6532 void H248_AmmsReply::PrintOn(ostream & strm) const
6533 {
6534   int indent = strm.precision() + 2;
6535   strm << "{\n";
6536   strm << setw(indent+16) << "terminationID = " << setprecision(indent) << m_terminationID << '\n';
6537   if (HasOptionalField(e_terminationAudit))
6538     strm << setw(indent+19) << "terminationAudit = " << setprecision(indent) << m_terminationAudit << '\n';
6539   strm << setw(indent-1) << setprecision(indent-2) << "}";
6540 }
6541 #endif
6542
6543
6544 PObject::Comparison H248_AmmsReply::Compare(const PObject & obj) const
6545 {
6546 #ifndef PASN_LEANANDMEAN
6547   PAssert(PIsDescendant(&obj, H248_AmmsReply), PInvalidCast);
6548 #endif
6549   const H248_AmmsReply & other = (const H248_AmmsReply &)obj;
6550
6551   Comparison result;
6552
6553   if ((result = m_terminationID.Compare(other.m_terminationID)) != EqualTo)
6554     return result;
6555   if ((result = m_terminationAudit.Compare(other.m_terminationAudit)) != EqualTo)
6556     return result;
6557
6558   return PASN_Sequence::Compare(other);
6559 }
6560
6561
6562 PINDEX H248_AmmsReply::GetDataLength() const
6563 {
6564   PINDEX length = 0;
6565   length += m_terminationID.GetObjectLength();
6566   if (HasOptionalField(e_terminationAudit))
6567     length += m_terminationAudit.GetObjectLength();
6568   return length;
6569 }
6570
6571
6572 BOOL H248_AmmsReply::Decode(PASN_Stream & strm)
6573 {
6574   if (!PreambleDecode(strm))
6575     return FALSE;
6576
6577   if (!m_terminationID.Decode(strm))
6578     return FALSE;
6579   if (HasOptionalField(e_terminationAudit) && !m_terminationAudit.Decode(strm))
6580     return FALSE;
6581
6582   return UnknownExtensionsDecode(strm);
6583 }
6584
6585
6586 void H248_AmmsReply::Encode(PASN_Stream & strm) const
6587 {
6588   PreambleEncode(strm);
6589
6590   m_terminationID.Encode(strm);
6591   if (HasOptionalField(e_terminationAudit))
6592     m_terminationAudit.Encode(strm);
6593
6594   UnknownExtensionsEncode(strm);
6595 }
6596
6597
6598 PObject * H248_AmmsReply::Clone() const
6599 {
6600 #ifndef PASN_LEANANDMEAN
6601   PAssert(IsClass(H248_AmmsReply::Class()), PInvalidCast);
6602 #endif
6603   return new H248_AmmsReply(*this);
6604 }
6605
6606
6607 //
6608 // AuditDescriptor
6609 //
6610
6611 H248_AuditDescriptor::H248_AuditDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
6612   : PASN_Sequence(tag, tagClass, 1, TRUE, 1)
6613 {
6614 }
6615
6616
6617 #ifndef PASN_NOPRINTON
6618 void H248_AuditDescriptor::PrintOn(ostream & strm) const
6619 {
6620   int indent = strm.precision() + 2;
6621   strm << "{\n";
6622   if (HasOptionalField(e_auditToken))
6623     strm << setw(indent+13) << "auditToken = " << setprecision(indent) << m_auditToken << '\n';
6624   if (HasOptionalField(e_auditPropertyToken))
6625     strm << setw(indent+21) << "auditPropertyToken = " << setprecision(indent) << m_auditPropertyToken << '\n';
6626   strm << setw(indent-1) << setprecision(indent-2) << "}";
6627 }
6628 #endif
6629
6630
6631 PObject::Comparison H248_AuditDescriptor::Compare(const PObject & obj) const
6632 {
6633 #ifndef PASN_LEANANDMEAN
6634   PAssert(PIsDescendant(&obj, H248_AuditDescriptor), PInvalidCast);
6635 #endif
6636   const H248_AuditDescriptor & other = (const H248_AuditDescriptor &)obj;
6637
6638   Comparison result;
6639
6640   if ((result = m_auditToken.Compare(other.m_auditToken)) != EqualTo)
6641     return result;
6642
6643   return PASN_Sequence::Compare(other);
6644 }
6645
6646
6647 PINDEX H248_AuditDescriptor::GetDataLength() const
6648 {
6649   PINDEX length = 0;
6650   if (HasOptionalField(e_auditToken))
6651     length += m_auditToken.GetObjectLength();
6652   return length;
6653 }
6654
6655
6656 BOOL H248_AuditDescriptor::Decode(PASN_Stream & strm)
6657 {
6658   if (!PreambleDecode(strm))
6659     return FALSE;
6660
6661   if (HasOptionalField(e_auditToken) && !m_auditToken.Decode(strm))
6662     return FALSE;
6663   if (!KnownExtensionDecode(strm, e_auditPropertyToken, m_auditPropertyToken))
6664     return FALSE;
6665
6666   return UnknownExtensionsDecode(strm);
6667 }
6668
6669
6670 void H248_AuditDescriptor::Encode(PASN_Stream & strm) const
6671 {
6672   PreambleEncode(strm);
6673
6674   if (HasOptionalField(e_auditToken))
6675     m_auditToken.Encode(strm);
6676   KnownExtensionEncode(strm, e_auditPropertyToken, m_auditPropertyToken);
6677
6678   UnknownExtensionsEncode(strm);
6679 }
6680
6681
6682 PObject * H248_AuditDescriptor::Clone() const
6683 {
6684 #ifndef PASN_LEANANDMEAN
6685   PAssert(IsClass(H248_AuditDescriptor::Class()), PInvalidCast);
6686 #endif
6687   return new H248_AuditDescriptor(*this);
6688 }
6689
6690
6691 //
6692 // IndAudLocalControlDescriptor
6693 //
6694
6695 H248_IndAudLocalControlDescriptor::H248_IndAudLocalControlDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
6696   : PASN_Sequence(tag, tagClass, 4, TRUE, 0)
6697 {
6698 }
6699
6700
6701 #ifndef PASN_NOPRINTON
6702 void H248_IndAudLocalControlDescriptor::PrintOn(ostream & strm) const
6703 {
6704   int indent = strm.precision() + 2;
6705   strm << "{\n";
6706   if (HasOptionalField(e_streamMode))
6707     strm << setw(indent+13) << "streamMode = " << setprecision(indent) << m_streamMode << '\n';
6708   if (HasOptionalField(e_reserveValue))
6709     strm << setw(indent+15) << "reserveValue = " << setprecision(indent) << m_reserveValue << '\n';
6710   if (HasOptionalField(e_reserveGroup))
6711     strm << setw(indent+15) << "reserveGroup = " << setprecision(indent) << m_reserveGroup << '\n';
6712   if (HasOptionalField(e_propertyParms))
6713     strm << setw(indent+16) << "propertyParms = " << setprecision(indent) << m_propertyParms << '\n';
6714   strm << setw(indent-1) << setprecision(indent-2) << "}";
6715 }
6716 #endif
6717
6718
6719 PObject::Comparison H248_IndAudLocalControlDescriptor::Compare(const PObject & obj) const
6720 {
6721 #ifndef PASN_LEANANDMEAN
6722   PAssert(PIsDescendant(&obj, H248_IndAudLocalControlDescriptor), PInvalidCast);
6723 #endif
6724   const H248_IndAudLocalControlDescriptor & other = (const H248_IndAudLocalControlDescriptor &)obj;
6725
6726   Comparison result;
6727
6728   if ((result = m_streamMode.Compare(other.m_streamMode)) != EqualTo)
6729     return result;
6730   if ((result = m_reserveValue.Compare(other.m_reserveValue)) != EqualTo)
6731     return result;
6732   if ((result = m_reserveGroup.Compare(other.m_reserveGroup)) != EqualTo)
6733     return result;
6734   if ((result = m_propertyParms.Compare(other.m_propertyParms)) != EqualTo)
6735     return result;
6736
6737   return PASN_Sequence::Compare(other);
6738 }
6739
6740
6741 PINDEX H248_IndAudLocalControlDescriptor::GetDataLength() const
6742 {
6743   PINDEX length = 0;
6744   if (HasOptionalField(e_streamMode))
6745     length += m_streamMode.GetObjectLength();
6746   if (HasOptionalField(e_reserveValue))
6747     length += m_reserveValue.GetObjectLength();
6748   if (HasOptionalField(e_reserveGroup))
6749     length += m_reserveGroup.GetObjectLength();
6750   if (HasOptionalField(e_propertyParms))
6751     length += m_propertyParms.GetObjectLength();
6752   return length;
6753 }
6754
6755
6756 BOOL H248_IndAudLocalControlDescriptor::Decode(PASN_Stream & strm)
6757 {
6758   if (!PreambleDecode(strm))
6759     return FALSE;
6760
6761   if (HasOptionalField(e_streamMode) && !m_streamMode.Decode(strm))
6762     return FALSE;
6763   if (HasOptionalField(e_reserveValue) && !m_reserveValue.Decode(strm))
6764     return FALSE;
6765   if (HasOptionalField(e_reserveGroup) && !m_reserveGroup.Decode(strm))
6766     return FALSE;
6767   if (HasOptionalField(e_propertyParms) && !m_propertyParms.Decode(strm))
6768     return FALSE;
6769
6770   return UnknownExtensionsDecode(strm);
6771 }
6772
6773
6774 void H248_IndAudLocalControlDescriptor::Encode(PASN_Stream & strm) const
6775 {
6776   PreambleEncode(strm);
6777
6778   if (HasOptionalField(e_streamMode))
6779     m_streamMode.Encode(strm);
6780   if (HasOptionalField(e_reserveValue))
6781     m_reserveValue.Encode(strm);
6782   if (HasOptionalField(e_reserveGroup))
6783     m_reserveGroup.Encode(strm);
6784   if (HasOptionalField(e_propertyParms))
6785     m_propertyParms.Encode(strm);
6786
6787   UnknownExtensionsEncode(strm);
6788 }
6789
6790
6791 PObject * H248_IndAudLocalControlDescriptor::Clone() const
6792 {
6793 #ifndef PASN_LEANANDMEAN
6794   PAssert(IsClass(H248_IndAudLocalControlDescriptor::Class()), PInvalidCast);
6795 #endif
6796   return new H248_IndAudLocalControlDescriptor(*this);
6797 }
6798
6799
6800 //
6801 // IndAudPropertyParm
6802 //
6803
6804 H248_IndAudPropertyParm::H248_IndAudPropertyParm(unsigned tag, PASN_Object::TagClass tagClass)
6805   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
6806 {
6807 }
6808
6809
6810 #ifndef PASN_NOPRINTON
6811 void H248_IndAudPropertyParm::PrintOn(ostream & strm) const
6812 {
6813   int indent = strm.precision() + 2;
6814   strm << "{\n";
6815   strm << setw(indent+7) << "name = " << setprecision(indent) << m_name << '\n';
6816   strm << setw(indent-1) << setprecision(indent-2) << "}";
6817 }
6818 #endif
6819
6820
6821 PObject::Comparison H248_IndAudPropertyParm::Compare(const PObject & obj) const
6822 {
6823 #ifndef PASN_LEANANDMEAN
6824   PAssert(PIsDescendant(&obj, H248_IndAudPropertyParm), PInvalidCast);
6825 #endif
6826   const H248_IndAudPropertyParm & other = (const H248_IndAudPropertyParm &)obj;
6827
6828   Comparison result;
6829
6830   if ((result = m_name.Compare(other.m_name)) != EqualTo)
6831     return result;
6832
6833   return PASN_Sequence::Compare(other);
6834 }
6835
6836
6837 PINDEX H248_IndAudPropertyParm::GetDataLength() const
6838 {
6839   PINDEX length = 0;
6840   length += m_name.GetObjectLength();
6841   return length;
6842 }
6843
6844
6845 BOOL H248_IndAudPropertyParm::Decode(PASN_Stream & strm)
6846 {
6847   if (!PreambleDecode(strm))
6848     return FALSE;
6849
6850   if (!m_name.Decode(strm))
6851     return FALSE;
6852
6853   return UnknownExtensionsDecode(strm);
6854 }
6855
6856
6857 void H248_IndAudPropertyParm::Encode(PASN_Stream & strm) const
6858 {
6859   PreambleEncode(strm);
6860
6861   m_name.Encode(strm);
6862
6863   UnknownExtensionsEncode(strm);
6864 }
6865
6866
6867 PObject * H248_IndAudPropertyParm::Clone() const
6868 {
6869 #ifndef PASN_LEANANDMEAN
6870   PAssert(IsClass(H248_IndAudPropertyParm::Class()), PInvalidCast);
6871 #endif
6872   return new H248_IndAudPropertyParm(*this);
6873 }
6874
6875
6876 //
6877 // IndAudLocalRemoteDescriptor
6878 //
6879
6880 H248_IndAudLocalRemoteDescriptor::H248_IndAudLocalRemoteDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
6881   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
6882 {
6883   m_propGroupID.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
6884 }
6885
6886
6887 #ifndef PASN_NOPRINTON
6888 void H248_IndAudLocalRemoteDescriptor::PrintOn(ostream & strm) const
6889 {
6890   int indent = strm.precision() + 2;
6891   strm << "{\n";
6892   if (HasOptionalField(e_propGroupID))
6893     strm << setw(indent+14) << "propGroupID = " << setprecision(indent) << m_propGroupID << '\n';
6894   strm << setw(indent+11) << "propGrps = " << setprecision(indent) << m_propGrps << '\n';
6895   strm << setw(indent-1) << setprecision(indent-2) << "}";
6896 }
6897 #endif
6898
6899
6900 PObject::Comparison H248_IndAudLocalRemoteDescriptor::Compare(const PObject & obj) const
6901 {
6902 #ifndef PASN_LEANANDMEAN
6903   PAssert(PIsDescendant(&obj, H248_IndAudLocalRemoteDescriptor), PInvalidCast);
6904 #endif
6905   const H248_IndAudLocalRemoteDescriptor & other = (const H248_IndAudLocalRemoteDescriptor &)obj;
6906
6907   Comparison result;
6908
6909   if ((result = m_propGroupID.Compare(other.m_propGroupID)) != EqualTo)
6910     return result;
6911   if ((result = m_propGrps.Compare(other.m_propGrps)) != EqualTo)
6912     return result;
6913
6914   return PASN_Sequence::Compare(other);
6915 }
6916
6917
6918 PINDEX H248_IndAudLocalRemoteDescriptor::GetDataLength() const
6919 {
6920   PINDEX length = 0;
6921   if (HasOptionalField(e_propGroupID))
6922     length += m_propGroupID.GetObjectLength();
6923   length += m_propGrps.GetObjectLength();
6924   return length;
6925 }
6926
6927
6928 BOOL H248_IndAudLocalRemoteDescriptor::Decode(PASN_Stream & strm)
6929 {
6930   if (!PreambleDecode(strm))
6931     return FALSE;
6932
6933   if (HasOptionalField(e_propGroupID) && !m_propGroupID.Decode(strm))
6934     return FALSE;
6935   if (!m_propGrps.Decode(strm))
6936     return FALSE;
6937
6938   return UnknownExtensionsDecode(strm);
6939 }
6940
6941
6942 void H248_IndAudLocalRemoteDescriptor::Encode(PASN_Stream & strm) const
6943 {
6944   PreambleEncode(strm);
6945
6946   if (HasOptionalField(e_propGroupID))
6947     m_propGroupID.Encode(strm);
6948   m_propGrps.Encode(strm);
6949
6950   UnknownExtensionsEncode(strm);
6951 }
6952
6953
6954 PObject * H248_IndAudLocalRemoteDescriptor::Clone() const
6955 {
6956 #ifndef PASN_LEANANDMEAN
6957   PAssert(IsClass(H248_IndAudLocalRemoteDescriptor::Class()), PInvalidCast);
6958 #endif
6959   return new H248_IndAudLocalRemoteDescriptor(*this);
6960 }
6961
6962
6963 //
6964 // IndAudTerminationStateDescriptor
6965 //
6966
6967 H248_IndAudTerminationStateDescriptor::H248_IndAudTerminationStateDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
6968   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
6969 {
6970 }
6971
6972
6973 #ifndef PASN_NOPRINTON
6974 void H248_IndAudTerminationStateDescriptor::PrintOn(ostream & strm) const
6975 {
6976   int indent = strm.precision() + 2;
6977   strm << "{\n";
6978   strm << setw(indent+16) << "propertyParms = " << setprecision(indent) << m_propertyParms << '\n';
6979   if (HasOptionalField(e_eventBufferControl))
6980     strm << setw(indent+21) << "eventBufferControl = " << setprecision(indent) << m_eventBufferControl << '\n';
6981   if (HasOptionalField(e_serviceState))
6982     strm << setw(indent+15) << "serviceState = " << setprecision(indent) << m_serviceState << '\n';
6983   strm << setw(indent-1) << setprecision(indent-2) << "}";
6984 }
6985 #endif
6986
6987
6988 PObject::Comparison H248_IndAudTerminationStateDescriptor::Compare(const PObject & obj) const
6989 {
6990 #ifndef PASN_LEANANDMEAN
6991   PAssert(PIsDescendant(&obj, H248_IndAudTerminationStateDescriptor), PInvalidCast);
6992 #endif
6993   const H248_IndAudTerminationStateDescriptor & other = (const H248_IndAudTerminationStateDescriptor &)obj;
6994
6995   Comparison result;
6996
6997   if ((result = m_propertyParms.Compare(other.m_propertyParms)) != EqualTo)
6998     return result;
6999   if ((result = m_eventBufferControl.Compare(other.m_eventBufferControl)) != EqualTo)
7000     return result;
7001   if ((result = m_serviceState.Compare(other.m_serviceState)) != EqualTo)
7002     return result;
7003
7004   return PASN_Sequence::Compare(other);
7005 }
7006
7007
7008 PINDEX H248_IndAudTerminationStateDescriptor::GetDataLength() const
7009 {
7010   PINDEX length = 0;
7011   length += m_propertyParms.GetObjectLength();
7012   if (HasOptionalField(e_eventBufferControl))
7013     length += m_eventBufferControl.GetObjectLength();
7014   if (HasOptionalField(e_serviceState))
7015     length += m_serviceState.GetObjectLength();
7016   return length;
7017 }
7018
7019
7020 BOOL H248_IndAudTerminationStateDescriptor::Decode(PASN_Stream & strm)
7021 {
7022   if (!PreambleDecode(strm))
7023     return FALSE;
7024
7025   if (!m_propertyParms.Decode(strm))
7026     return FALSE;
7027   if (HasOptionalField(e_eventBufferControl) && !m_eventBufferControl.Decode(strm))
7028     return FALSE;
7029   if (HasOptionalField(e_serviceState) && !m_serviceState.Decode(strm))
7030     return FALSE;
7031
7032   return UnknownExtensionsDecode(strm);
7033 }
7034
7035
7036 void H248_IndAudTerminationStateDescriptor::Encode(PASN_Stream & strm) const
7037 {
7038   PreambleEncode(strm);
7039
7040   m_propertyParms.Encode(strm);
7041   if (HasOptionalField(e_eventBufferControl))
7042     m_eventBufferControl.Encode(strm);
7043   if (HasOptionalField(e_serviceState))
7044     m_serviceState.Encode(strm);
7045
7046   UnknownExtensionsEncode(strm);
7047 }
7048
7049
7050 PObject * H248_IndAudTerminationStateDescriptor::Clone() const
7051 {
7052 #ifndef PASN_LEANANDMEAN
7053   PAssert(IsClass(H248_IndAudTerminationStateDescriptor::Class()), PInvalidCast);
7054 #endif
7055   return new H248_IndAudTerminationStateDescriptor(*this);
7056 }
7057
7058
7059 //
7060 // IndAudEventsDescriptor
7061 //
7062
7063 H248_IndAudEventsDescriptor::H248_IndAudEventsDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
7064   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
7065 {
7066 }
7067
7068
7069 #ifndef PASN_NOPRINTON
7070 void H248_IndAudEventsDescriptor::PrintOn(ostream & strm) const
7071 {
7072   int indent = strm.precision() + 2;
7073   strm << "{\n";
7074   if (HasOptionalField(e_requestID))
7075     strm << setw(indent+12) << "requestID = " << setprecision(indent) << m_requestID << '\n';
7076   strm << setw(indent+11) << "pkgdName = " << setprecision(indent) << m_pkgdName << '\n';
7077   if (HasOptionalField(e_streamID))
7078     strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
7079   strm << setw(indent-1) << setprecision(indent-2) << "}";
7080 }
7081 #endif
7082
7083
7084 PObject::Comparison H248_IndAudEventsDescriptor::Compare(const PObject & obj) const
7085 {
7086 #ifndef PASN_LEANANDMEAN
7087   PAssert(PIsDescendant(&obj, H248_IndAudEventsDescriptor), PInvalidCast);
7088 #endif
7089   const H248_IndAudEventsDescriptor & other = (const H248_IndAudEventsDescriptor &)obj;
7090
7091   Comparison result;
7092
7093   if ((result = m_requestID.Compare(other.m_requestID)) != EqualTo)
7094     return result;
7095   if ((result = m_pkgdName.Compare(other.m_pkgdName)) != EqualTo)
7096     return result;
7097   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
7098     return result;
7099
7100   return PASN_Sequence::Compare(other);
7101 }
7102
7103
7104 PINDEX H248_IndAudEventsDescriptor::GetDataLength() const
7105 {
7106   PINDEX length = 0;
7107   if (HasOptionalField(e_requestID))
7108     length += m_requestID.GetObjectLength();
7109   length += m_pkgdName.GetObjectLength();
7110   if (HasOptionalField(e_streamID))
7111     length += m_streamID.GetObjectLength();
7112   return length;
7113 }
7114
7115
7116 BOOL H248_IndAudEventsDescriptor::Decode(PASN_Stream & strm)
7117 {
7118   if (!PreambleDecode(strm))
7119     return FALSE;
7120
7121   if (HasOptionalField(e_requestID) && !m_requestID.Decode(strm))
7122     return FALSE;
7123   if (!m_pkgdName.Decode(strm))
7124     return FALSE;
7125   if (HasOptionalField(e_streamID) && !m_streamID.Decode(strm))
7126     return FALSE;
7127
7128   return UnknownExtensionsDecode(strm);
7129 }
7130
7131
7132 void H248_IndAudEventsDescriptor::Encode(PASN_Stream & strm) const
7133 {
7134   PreambleEncode(strm);
7135
7136   if (HasOptionalField(e_requestID))
7137     m_requestID.Encode(strm);
7138   m_pkgdName.Encode(strm);
7139   if (HasOptionalField(e_streamID))
7140     m_streamID.Encode(strm);
7141
7142   UnknownExtensionsEncode(strm);
7143 }
7144
7145
7146 PObject * H248_IndAudEventsDescriptor::Clone() const
7147 {
7148 #ifndef PASN_LEANANDMEAN
7149   PAssert(IsClass(H248_IndAudEventsDescriptor::Class()), PInvalidCast);
7150 #endif
7151   return new H248_IndAudEventsDescriptor(*this);
7152 }
7153
7154
7155 //
7156 // IndAudEventBufferDescriptor
7157 //
7158
7159 H248_IndAudEventBufferDescriptor::H248_IndAudEventBufferDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
7160   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
7161 {
7162 }
7163
7164
7165 #ifndef PASN_NOPRINTON
7166 void H248_IndAudEventBufferDescriptor::PrintOn(ostream & strm) const
7167 {
7168   int indent = strm.precision() + 2;
7169   strm << "{\n";
7170   strm << setw(indent+12) << "eventName = " << setprecision(indent) << m_eventName << '\n';
7171   if (HasOptionalField(e_streamID))
7172     strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
7173   strm << setw(indent-1) << setprecision(indent-2) << "}";
7174 }
7175 #endif
7176
7177
7178 PObject::Comparison H248_IndAudEventBufferDescriptor::Compare(const PObject & obj) const
7179 {
7180 #ifndef PASN_LEANANDMEAN
7181   PAssert(PIsDescendant(&obj, H248_IndAudEventBufferDescriptor), PInvalidCast);
7182 #endif
7183   const H248_IndAudEventBufferDescriptor & other = (const H248_IndAudEventBufferDescriptor &)obj;
7184
7185   Comparison result;
7186
7187   if ((result = m_eventName.Compare(other.m_eventName)) != EqualTo)
7188     return result;
7189   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
7190     return result;
7191
7192   return PASN_Sequence::Compare(other);
7193 }
7194
7195
7196 PINDEX H248_IndAudEventBufferDescriptor::GetDataLength() const
7197 {
7198   PINDEX length = 0;
7199   length += m_eventName.GetObjectLength();
7200   if (HasOptionalField(e_streamID))
7201     length += m_streamID.GetObjectLength();
7202   return length;
7203 }
7204
7205
7206 BOOL H248_IndAudEventBufferDescriptor::Decode(PASN_Stream & strm)
7207 {
7208   if (!PreambleDecode(strm))
7209     return FALSE;
7210
7211   if (!m_eventName.Decode(strm))
7212     return FALSE;
7213   if (HasOptionalField(e_streamID) && !m_streamID.Decode(strm))
7214     return FALSE;
7215
7216   return UnknownExtensionsDecode(strm);
7217 }
7218
7219
7220 void H248_IndAudEventBufferDescriptor::Encode(PASN_Stream & strm) const
7221 {
7222   PreambleEncode(strm);
7223
7224   m_eventName.Encode(strm);
7225   if (HasOptionalField(e_streamID))
7226     m_streamID.Encode(strm);
7227
7228   UnknownExtensionsEncode(strm);
7229 }
7230
7231
7232 PObject * H248_IndAudEventBufferDescriptor::Clone() const
7233 {
7234 #ifndef PASN_LEANANDMEAN
7235   PAssert(IsClass(H248_IndAudEventBufferDescriptor::Class()), PInvalidCast);
7236 #endif
7237   return new H248_IndAudEventBufferDescriptor(*this);
7238 }
7239
7240
7241 //
7242 // IndAudSignal
7243 //
7244
7245 H248_IndAudSignal::H248_IndAudSignal(unsigned tag, PASN_Object::TagClass tagClass)
7246   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
7247 {
7248 }
7249
7250
7251 #ifndef PASN_NOPRINTON
7252 void H248_IndAudSignal::PrintOn(ostream & strm) const
7253 {
7254   int indent = strm.precision() + 2;
7255   strm << "{\n";
7256   strm << setw(indent+13) << "signalName = " << setprecision(indent) << m_signalName << '\n';
7257   if (HasOptionalField(e_streamID))
7258     strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
7259   strm << setw(indent-1) << setprecision(indent-2) << "}";
7260 }
7261 #endif
7262
7263
7264 PObject::Comparison H248_IndAudSignal::Compare(const PObject & obj) const
7265 {
7266 #ifndef PASN_LEANANDMEAN
7267   PAssert(PIsDescendant(&obj, H248_IndAudSignal), PInvalidCast);
7268 #endif
7269   const H248_IndAudSignal & other = (const H248_IndAudSignal &)obj;
7270
7271   Comparison result;
7272
7273   if ((result = m_signalName.Compare(other.m_signalName)) != EqualTo)
7274     return result;
7275   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
7276     return result;
7277
7278   return PASN_Sequence::Compare(other);
7279 }
7280
7281
7282 PINDEX H248_IndAudSignal::GetDataLength() const
7283 {
7284   PINDEX length = 0;
7285   length += m_signalName.GetObjectLength();
7286   if (HasOptionalField(e_streamID))
7287     length += m_streamID.GetObjectLength();
7288   return length;
7289 }
7290
7291
7292 BOOL H248_IndAudSignal::Decode(PASN_Stream & strm)
7293 {
7294   if (!PreambleDecode(strm))
7295     return FALSE;
7296
7297   if (!m_signalName.Decode(strm))
7298     return FALSE;
7299   if (HasOptionalField(e_streamID) && !m_streamID.Decode(strm))
7300     return FALSE;
7301
7302   return UnknownExtensionsDecode(strm);
7303 }
7304
7305
7306 void H248_IndAudSignal::Encode(PASN_Stream & strm) const
7307 {
7308   PreambleEncode(strm);
7309
7310   m_signalName.Encode(strm);
7311   if (HasOptionalField(e_streamID))
7312     m_streamID.Encode(strm);
7313
7314   UnknownExtensionsEncode(strm);
7315 }
7316
7317
7318 PObject * H248_IndAudSignal::Clone() const
7319 {
7320 #ifndef PASN_LEANANDMEAN
7321   PAssert(IsClass(H248_IndAudSignal::Class()), PInvalidCast);
7322 #endif
7323   return new H248_IndAudSignal(*this);
7324 }
7325
7326
7327 //
7328 // IndAudDigitMapDescriptor
7329 //
7330
7331 H248_IndAudDigitMapDescriptor::H248_IndAudDigitMapDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
7332   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
7333 {
7334 }
7335
7336
7337 #ifndef PASN_NOPRINTON
7338 void H248_IndAudDigitMapDescriptor::PrintOn(ostream & strm) const
7339 {
7340   int indent = strm.precision() + 2;
7341   strm << "{\n";
7342   if (HasOptionalField(e_digitMapName))
7343     strm << setw(indent+15) << "digitMapName = " << setprecision(indent) << m_digitMapName << '\n';
7344   strm << setw(indent-1) << setprecision(indent-2) << "}";
7345 }
7346 #endif
7347
7348
7349 PObject::Comparison H248_IndAudDigitMapDescriptor::Compare(const PObject & obj) const
7350 {
7351 #ifndef PASN_LEANANDMEAN
7352   PAssert(PIsDescendant(&obj, H248_IndAudDigitMapDescriptor), PInvalidCast);
7353 #endif
7354   const H248_IndAudDigitMapDescriptor & other = (const H248_IndAudDigitMapDescriptor &)obj;
7355
7356   Comparison result;
7357
7358   if ((result = m_digitMapName.Compare(other.m_digitMapName)) != EqualTo)
7359     return result;
7360
7361   return PASN_Sequence::Compare(other);
7362 }
7363
7364
7365 PINDEX H248_IndAudDigitMapDescriptor::GetDataLength() const
7366 {
7367   PINDEX length = 0;
7368   if (HasOptionalField(e_digitMapName))
7369     length += m_digitMapName.GetObjectLength();
7370   return length;
7371 }
7372
7373
7374 BOOL H248_IndAudDigitMapDescriptor::Decode(PASN_Stream & strm)
7375 {
7376   if (!PreambleDecode(strm))
7377     return FALSE;
7378
7379   if (HasOptionalField(e_digitMapName) && !m_digitMapName.Decode(strm))
7380     return FALSE;
7381
7382   return UnknownExtensionsDecode(strm);
7383 }
7384
7385
7386 void H248_IndAudDigitMapDescriptor::Encode(PASN_Stream & strm) const
7387 {
7388   PreambleEncode(strm);
7389
7390   if (HasOptionalField(e_digitMapName))
7391     m_digitMapName.Encode(strm);
7392
7393   UnknownExtensionsEncode(strm);
7394 }
7395
7396
7397 PObject * H248_IndAudDigitMapDescriptor::Clone() const
7398 {
7399 #ifndef PASN_LEANANDMEAN
7400   PAssert(IsClass(H248_IndAudDigitMapDescriptor::Class()), PInvalidCast);
7401 #endif
7402   return new H248_IndAudDigitMapDescriptor(*this);
7403 }
7404
7405
7406 //
7407 // IndAudStatisticsDescriptor
7408 //
7409
7410 H248_IndAudStatisticsDescriptor::H248_IndAudStatisticsDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
7411   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
7412 {
7413 }
7414
7415
7416 #ifndef PASN_NOPRINTON
7417 void H248_IndAudStatisticsDescriptor::PrintOn(ostream & strm) const
7418 {
7419   int indent = strm.precision() + 2;
7420   strm << "{\n";
7421   strm << setw(indent+11) << "statName = " << setprecision(indent) << m_statName << '\n';
7422   strm << setw(indent-1) << setprecision(indent-2) << "}";
7423 }
7424 #endif
7425
7426
7427 PObject::Comparison H248_IndAudStatisticsDescriptor::Compare(const PObject & obj) const
7428 {
7429 #ifndef PASN_LEANANDMEAN
7430   PAssert(PIsDescendant(&obj, H248_IndAudStatisticsDescriptor), PInvalidCast);
7431 #endif
7432   const H248_IndAudStatisticsDescriptor & other = (const H248_IndAudStatisticsDescriptor &)obj;
7433
7434   Comparison result;
7435
7436   if ((result = m_statName.Compare(other.m_statName)) != EqualTo)
7437     return result;
7438
7439   return PASN_Sequence::Compare(other);
7440 }
7441
7442
7443 PINDEX H248_IndAudStatisticsDescriptor::GetDataLength() const
7444 {
7445   PINDEX length = 0;
7446   length += m_statName.GetObjectLength();
7447   return length;
7448 }
7449
7450
7451 BOOL H248_IndAudStatisticsDescriptor::Decode(PASN_Stream & strm)
7452 {
7453   if (!PreambleDecode(strm))
7454     return FALSE;
7455
7456   if (!m_statName.Decode(strm))
7457     return FALSE;
7458
7459   return UnknownExtensionsDecode(strm);
7460 }
7461
7462
7463 void H248_IndAudStatisticsDescriptor::Encode(PASN_Stream & strm) const
7464 {
7465   PreambleEncode(strm);
7466
7467   m_statName.Encode(strm);
7468
7469   UnknownExtensionsEncode(strm);
7470 }
7471
7472
7473 PObject * H248_IndAudStatisticsDescriptor::Clone() const
7474 {
7475 #ifndef PASN_LEANANDMEAN
7476   PAssert(IsClass(H248_IndAudStatisticsDescriptor::Class()), PInvalidCast);
7477 #endif
7478   return new H248_IndAudStatisticsDescriptor(*this);
7479 }
7480
7481
7482 //
7483 // IndAudPackagesDescriptor
7484 //
7485
7486 H248_IndAudPackagesDescriptor::H248_IndAudPackagesDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
7487   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
7488 {
7489   m_packageVersion.SetConstraints(PASN_Object::FixedConstraint, 0, 99);
7490 }
7491
7492
7493 #ifndef PASN_NOPRINTON
7494 void H248_IndAudPackagesDescriptor::PrintOn(ostream & strm) const
7495 {
7496   int indent = strm.precision() + 2;
7497   strm << "{\n";
7498   strm << setw(indent+14) << "packageName = " << setprecision(indent) << m_packageName << '\n';
7499   strm << setw(indent+17) << "packageVersion = " << setprecision(indent) << m_packageVersion << '\n';
7500   strm << setw(indent-1) << setprecision(indent-2) << "}";
7501 }
7502 #endif
7503
7504
7505 PObject::Comparison H248_IndAudPackagesDescriptor::Compare(const PObject & obj) const
7506 {
7507 #ifndef PASN_LEANANDMEAN
7508   PAssert(PIsDescendant(&obj, H248_IndAudPackagesDescriptor), PInvalidCast);
7509 #endif
7510   const H248_IndAudPackagesDescriptor & other = (const H248_IndAudPackagesDescriptor &)obj;
7511
7512   Comparison result;
7513
7514   if ((result = m_packageName.Compare(other.m_packageName)) != EqualTo)
7515     return result;
7516   if ((result = m_packageVersion.Compare(other.m_packageVersion)) != EqualTo)
7517     return result;
7518
7519   return PASN_Sequence::Compare(other);
7520 }
7521
7522
7523 PINDEX H248_IndAudPackagesDescriptor::GetDataLength() const
7524 {
7525   PINDEX length = 0;
7526   length += m_packageName.GetObjectLength();
7527   length += m_packageVersion.GetObjectLength();
7528   return length;
7529 }
7530
7531
7532 BOOL H248_IndAudPackagesDescriptor::Decode(PASN_Stream & strm)
7533 {
7534   if (!PreambleDecode(strm))
7535     return FALSE;
7536
7537   if (!m_packageName.Decode(strm))
7538     return FALSE;
7539   if (!m_packageVersion.Decode(strm))
7540     return FALSE;
7541
7542   return UnknownExtensionsDecode(strm);
7543 }
7544
7545
7546 void H248_IndAudPackagesDescriptor::Encode(PASN_Stream & strm) const
7547 {
7548   PreambleEncode(strm);
7549
7550   m_packageName.Encode(strm);
7551   m_packageVersion.Encode(strm);
7552
7553   UnknownExtensionsEncode(strm);
7554 }
7555
7556
7557 PObject * H248_IndAudPackagesDescriptor::Clone() const
7558 {
7559 #ifndef PASN_LEANANDMEAN
7560   PAssert(IsClass(H248_IndAudPackagesDescriptor::Class()), PInvalidCast);
7561 #endif
7562   return new H248_IndAudPackagesDescriptor(*this);
7563 }
7564
7565
7566 //
7567 // NotifyReply
7568 //
7569
7570 H248_NotifyReply::H248_NotifyReply(unsigned tag, PASN_Object::TagClass tagClass)
7571   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
7572 {
7573 }
7574
7575
7576 #ifndef PASN_NOPRINTON
7577 void H248_NotifyReply::PrintOn(ostream & strm) const
7578 {
7579   int indent = strm.precision() + 2;
7580   strm << "{\n";
7581   strm << setw(indent+16) << "terminationID = " << setprecision(indent) << m_terminationID << '\n';
7582   if (HasOptionalField(e_errorDescriptor))
7583     strm << setw(indent+18) << "errorDescriptor = " << setprecision(indent) << m_errorDescriptor << '\n';
7584   strm << setw(indent-1) << setprecision(indent-2) << "}";
7585 }
7586 #endif
7587
7588
7589 PObject::Comparison H248_NotifyReply::Compare(const PObject & obj) const
7590 {
7591 #ifndef PASN_LEANANDMEAN
7592   PAssert(PIsDescendant(&obj, H248_NotifyReply), PInvalidCast);
7593 #endif
7594   const H248_NotifyReply & other = (const H248_NotifyReply &)obj;
7595
7596   Comparison result;
7597
7598   if ((result = m_terminationID.Compare(other.m_terminationID)) != EqualTo)
7599     return result;
7600   if ((result = m_errorDescriptor.Compare(other.m_errorDescriptor)) != EqualTo)
7601     return result;
7602
7603   return PASN_Sequence::Compare(other);
7604 }
7605
7606
7607 PINDEX H248_NotifyReply::GetDataLength() const
7608 {
7609   PINDEX length = 0;
7610   length += m_terminationID.GetObjectLength();
7611   if (HasOptionalField(e_errorDescriptor))
7612     length += m_errorDescriptor.GetObjectLength();
7613   return length;
7614 }
7615
7616
7617 BOOL H248_NotifyReply::Decode(PASN_Stream & strm)
7618 {
7619   if (!PreambleDecode(strm))
7620     return FALSE;
7621
7622   if (!m_terminationID.Decode(strm))
7623     return FALSE;
7624   if (HasOptionalField(e_errorDescriptor) && !m_errorDescriptor.Decode(strm))
7625     return FALSE;
7626
7627   return UnknownExtensionsDecode(strm);
7628 }
7629
7630
7631 void H248_NotifyReply::Encode(PASN_Stream & strm) const
7632 {
7633   PreambleEncode(strm);
7634
7635   m_terminationID.Encode(strm);
7636   if (HasOptionalField(e_errorDescriptor))
7637     m_errorDescriptor.Encode(strm);
7638
7639   UnknownExtensionsEncode(strm);
7640 }
7641
7642
7643 PObject * H248_NotifyReply::Clone() const
7644 {
7645 #ifndef PASN_LEANANDMEAN
7646   PAssert(IsClass(H248_NotifyReply::Class()), PInvalidCast);
7647 #endif
7648   return new H248_NotifyReply(*this);
7649 }
7650
7651
7652 //
7653 // ObservedEventsDescriptor
7654 //
7655
7656 H248_ObservedEventsDescriptor::H248_ObservedEventsDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
7657   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
7658 {
7659 }
7660
7661
7662 #ifndef PASN_NOPRINTON
7663 void H248_ObservedEventsDescriptor::PrintOn(ostream & strm) const
7664 {
7665   int indent = strm.precision() + 2;
7666   strm << "{\n";
7667   strm << setw(indent+12) << "requestId = " << setprecision(indent) << m_requestId << '\n';
7668   strm << setw(indent+19) << "observedEventLst = " << setprecision(indent) << m_observedEventLst << '\n';
7669   strm << setw(indent-1) << setprecision(indent-2) << "}";
7670 }
7671 #endif
7672
7673
7674 PObject::Comparison H248_ObservedEventsDescriptor::Compare(const PObject & obj) const
7675 {
7676 #ifndef PASN_LEANANDMEAN
7677   PAssert(PIsDescendant(&obj, H248_ObservedEventsDescriptor), PInvalidCast);
7678 #endif
7679   const H248_ObservedEventsDescriptor & other = (const H248_ObservedEventsDescriptor &)obj;
7680
7681   Comparison result;
7682
7683   if ((result = m_requestId.Compare(other.m_requestId)) != EqualTo)
7684     return result;
7685   if ((result = m_observedEventLst.Compare(other.m_observedEventLst)) != EqualTo)
7686     return result;
7687
7688   return PASN_Sequence::Compare(other);
7689 }
7690
7691
7692 PINDEX H248_ObservedEventsDescriptor::GetDataLength() const
7693 {
7694   PINDEX length = 0;
7695   length += m_requestId.GetObjectLength();
7696   length += m_observedEventLst.GetObjectLength();
7697   return length;
7698 }
7699
7700
7701 BOOL H248_ObservedEventsDescriptor::Decode(PASN_Stream & strm)
7702 {
7703   if (!PreambleDecode(strm))
7704     return FALSE;
7705
7706   if (!m_requestId.Decode(strm))
7707     return FALSE;
7708   if (!m_observedEventLst.Decode(strm))
7709     return FALSE;
7710
7711   return UnknownExtensionsDecode(strm);
7712 }
7713
7714
7715 void H248_ObservedEventsDescriptor::Encode(PASN_Stream & strm) const
7716 {
7717   PreambleEncode(strm);
7718
7719   m_requestId.Encode(strm);
7720   m_observedEventLst.Encode(strm);
7721
7722   UnknownExtensionsEncode(strm);
7723 }
7724
7725
7726 PObject * H248_ObservedEventsDescriptor::Clone() const
7727 {
7728 #ifndef PASN_LEANANDMEAN
7729   PAssert(IsClass(H248_ObservedEventsDescriptor::Class()), PInvalidCast);
7730 #endif
7731   return new H248_ObservedEventsDescriptor(*this);
7732 }
7733
7734
7735 //
7736 // EventName
7737 //
7738
7739 H248_EventName::H248_EventName(unsigned tag, PASN_Object::TagClass tagClass)
7740   : H248_PkgdName(tag, tagClass)
7741 {
7742 }
7743
7744
7745 H248_EventName::H248_EventName(const char * v)
7746 {
7747   SetValue(v);
7748 }
7749
7750
7751 H248_EventName::H248_EventName(const PString & v)
7752 {
7753   SetValue(v);
7754 }
7755
7756
7757 H248_EventName::H248_EventName(const PBYTEArray & v)
7758 {
7759   SetValue(v);
7760 }
7761
7762
7763 H248_EventName & H248_EventName::operator=(const char * v)
7764 {
7765   SetValue(v);
7766   return *this;
7767 }
7768
7769
7770 H248_EventName & H248_EventName::operator=(const PString & v)
7771 {
7772   SetValue(v);
7773   return *this;
7774 }
7775
7776
7777 H248_EventName & H248_EventName::operator=(const PBYTEArray & v)
7778 {
7779   SetValue(v);
7780   return *this;
7781 }
7782
7783
7784 PObject * H248_EventName::Clone() const
7785 {
7786 #ifndef PASN_LEANANDMEAN
7787   PAssert(IsClass(H248_EventName::Class()), PInvalidCast);
7788 #endif
7789   return new H248_EventName(*this);
7790 }
7791
7792
7793 //
7794 // EventParameter
7795 //
7796
7797 H248_EventParameter::H248_EventParameter(unsigned tag, PASN_Object::TagClass tagClass)
7798   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
7799 {
7800 }
7801
7802
7803 #ifndef PASN_NOPRINTON
7804 void H248_EventParameter::PrintOn(ostream & strm) const
7805 {
7806   int indent = strm.precision() + 2;
7807   strm << "{\n";
7808   strm << setw(indent+21) << "eventParameterName = " << setprecision(indent) << m_eventParameterName << '\n';
7809   strm << setw(indent+8) << "value = " << setprecision(indent) << m_value << '\n';
7810   if (HasOptionalField(e_extraInfo))
7811     strm << setw(indent+12) << "extraInfo = " << setprecision(indent) << m_extraInfo << '\n';
7812   strm << setw(indent-1) << setprecision(indent-2) << "}";
7813 }
7814 #endif
7815
7816
7817 PObject::Comparison H248_EventParameter::Compare(const PObject & obj) const
7818 {
7819 #ifndef PASN_LEANANDMEAN
7820   PAssert(PIsDescendant(&obj, H248_EventParameter), PInvalidCast);
7821 #endif
7822   const H248_EventParameter & other = (const H248_EventParameter &)obj;
7823
7824   Comparison result;
7825
7826   if ((result = m_eventParameterName.Compare(other.m_eventParameterName)) != EqualTo)
7827     return result;
7828   if ((result = m_value.Compare(other.m_value)) != EqualTo)
7829     return result;
7830   if ((result = m_extraInfo.Compare(other.m_extraInfo)) != EqualTo)
7831     return result;
7832
7833   return PASN_Sequence::Compare(other);
7834 }
7835
7836
7837 PINDEX H248_EventParameter::GetDataLength() const
7838 {
7839   PINDEX length = 0;
7840   length += m_eventParameterName.GetObjectLength();
7841   length += m_value.GetObjectLength();
7842   if (HasOptionalField(e_extraInfo))
7843     length += m_extraInfo.GetObjectLength();
7844   return length;
7845 }
7846
7847
7848 BOOL H248_EventParameter::Decode(PASN_Stream & strm)
7849 {
7850   if (!PreambleDecode(strm))
7851     return FALSE;
7852
7853   if (!m_eventParameterName.Decode(strm))
7854     return FALSE;
7855   if (!m_value.Decode(strm))
7856     return FALSE;
7857   if (HasOptionalField(e_extraInfo) && !m_extraInfo.Decode(strm))
7858     return FALSE;
7859
7860   return UnknownExtensionsDecode(strm);
7861 }
7862
7863
7864 void H248_EventParameter::Encode(PASN_Stream & strm) const
7865 {
7866   PreambleEncode(strm);
7867
7868   m_eventParameterName.Encode(strm);
7869   m_value.Encode(strm);
7870   if (HasOptionalField(e_extraInfo))
7871     m_extraInfo.Encode(strm);
7872
7873   UnknownExtensionsEncode(strm);
7874 }
7875
7876
7877 PObject * H248_EventParameter::Clone() const
7878 {
7879 #ifndef PASN_LEANANDMEAN
7880   PAssert(IsClass(H248_EventParameter::Class()), PInvalidCast);
7881 #endif
7882   return new H248_EventParameter(*this);
7883 }
7884
7885
7886 //
7887 // ServiceChangeReply
7888 //
7889
7890 H248_ServiceChangeReply::H248_ServiceChangeReply(unsigned tag, PASN_Object::TagClass tagClass)
7891   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
7892 {
7893 }
7894
7895
7896 #ifndef PASN_NOPRINTON
7897 void H248_ServiceChangeReply::PrintOn(ostream & strm) const
7898 {
7899   int indent = strm.precision() + 2;
7900   strm << "{\n";
7901   strm << setw(indent+16) << "terminationID = " << setprecision(indent) << m_terminationID << '\n';
7902   strm << setw(indent+22) << "serviceChangeResult = " << setprecision(indent) << m_serviceChangeResult << '\n';
7903   strm << setw(indent-1) << setprecision(indent-2) << "}";
7904 }
7905 #endif
7906
7907
7908 PObject::Comparison H248_ServiceChangeReply::Compare(const PObject & obj) const
7909 {
7910 #ifndef PASN_LEANANDMEAN
7911   PAssert(PIsDescendant(&obj, H248_ServiceChangeReply), PInvalidCast);
7912 #endif
7913   const H248_ServiceChangeReply & other = (const H248_ServiceChangeReply &)obj;
7914
7915   Comparison result;
7916
7917   if ((result = m_terminationID.Compare(other.m_terminationID)) != EqualTo)
7918     return result;
7919   if ((result = m_serviceChangeResult.Compare(other.m_serviceChangeResult)) != EqualTo)
7920     return result;
7921
7922   return PASN_Sequence::Compare(other);
7923 }
7924
7925
7926 PINDEX H248_ServiceChangeReply::GetDataLength() const
7927 {
7928   PINDEX length = 0;
7929   length += m_terminationID.GetObjectLength();
7930   length += m_serviceChangeResult.GetObjectLength();
7931   return length;
7932 }
7933
7934
7935 BOOL H248_ServiceChangeReply::Decode(PASN_Stream & strm)
7936 {
7937   if (!PreambleDecode(strm))
7938     return FALSE;
7939
7940   if (!m_terminationID.Decode(strm))
7941     return FALSE;
7942   if (!m_serviceChangeResult.Decode(strm))
7943     return FALSE;
7944
7945   return UnknownExtensionsDecode(strm);
7946 }
7947
7948
7949 void H248_ServiceChangeReply::Encode(PASN_Stream & strm) const
7950 {
7951   PreambleEncode(strm);
7952
7953   m_terminationID.Encode(strm);
7954   m_serviceChangeResult.Encode(strm);
7955
7956   UnknownExtensionsEncode(strm);
7957 }
7958
7959
7960 PObject * H248_ServiceChangeReply::Clone() const
7961 {
7962 #ifndef PASN_LEANANDMEAN
7963   PAssert(IsClass(H248_ServiceChangeReply::Class()), PInvalidCast);
7964 #endif
7965   return new H248_ServiceChangeReply(*this);
7966 }
7967
7968
7969 //
7970 // TerminationID
7971 //
7972
7973 H248_TerminationID::H248_TerminationID(unsigned tag, PASN_Object::TagClass tagClass)
7974   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
7975 {
7976   m_id.SetConstraints(PASN_Object::FixedConstraint, 1, 8);
7977 }
7978
7979
7980 #ifndef PASN_NOPRINTON
7981 void H248_TerminationID::PrintOn(ostream & strm) const
7982 {
7983   int indent = strm.precision() + 2;
7984   strm << "{\n";
7985   strm << setw(indent+11) << "wildcard = " << setprecision(indent) << m_wildcard << '\n';
7986   strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
7987   strm << setw(indent-1) << setprecision(indent-2) << "}";
7988 }
7989 #endif
7990
7991
7992 PObject::Comparison H248_TerminationID::Compare(const PObject & obj) const
7993 {
7994 #ifndef PASN_LEANANDMEAN
7995   PAssert(PIsDescendant(&obj, H248_TerminationID), PInvalidCast);
7996 #endif
7997   const H248_TerminationID & other = (const H248_TerminationID &)obj;
7998
7999   Comparison result;
8000
8001   if ((result = m_wildcard.Compare(other.m_wildcard)) != EqualTo)
8002     return result;
8003   if ((result = m_id.Compare(other.m_id)) != EqualTo)
8004     return result;
8005
8006   return PASN_Sequence::Compare(other);
8007 }
8008
8009
8010 PINDEX H248_TerminationID::GetDataLength() const
8011 {
8012   PINDEX length = 0;
8013   length += m_wildcard.GetObjectLength();
8014   length += m_id.GetObjectLength();
8015   return length;
8016 }
8017
8018
8019 BOOL H248_TerminationID::Decode(PASN_Stream & strm)
8020 {
8021   if (!PreambleDecode(strm))
8022     return FALSE;
8023
8024   if (!m_wildcard.Decode(strm))
8025     return FALSE;
8026   if (!m_id.Decode(strm))
8027     return FALSE;
8028
8029   return UnknownExtensionsDecode(strm);
8030 }
8031
8032
8033 void H248_TerminationID::Encode(PASN_Stream & strm) const
8034 {
8035   PreambleEncode(strm);
8036
8037   m_wildcard.Encode(strm);
8038   m_id.Encode(strm);
8039
8040   UnknownExtensionsEncode(strm);
8041 }
8042
8043
8044 PObject * H248_TerminationID::Clone() const
8045 {
8046 #ifndef PASN_LEANANDMEAN
8047   PAssert(IsClass(H248_TerminationID::Class()), PInvalidCast);
8048 #endif
8049   return new H248_TerminationID(*this);
8050 }
8051
8052
8053 //
8054 // LocalControlDescriptor
8055 //
8056
8057 H248_LocalControlDescriptor::H248_LocalControlDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
8058   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
8059 {
8060 }
8061
8062
8063 #ifndef PASN_NOPRINTON
8064 void H248_LocalControlDescriptor::PrintOn(ostream & strm) const
8065 {
8066   int indent = strm.precision() + 2;
8067   strm << "{\n";
8068   if (HasOptionalField(e_streamMode))
8069     strm << setw(indent+13) << "streamMode = " << setprecision(indent) << m_streamMode << '\n';
8070   if (HasOptionalField(e_reserveValue))
8071     strm << setw(indent+15) << "reserveValue = " << setprecision(indent) << m_reserveValue << '\n';
8072   if (HasOptionalField(e_reserveGroup))
8073     strm << setw(indent+15) << "reserveGroup = " << setprecision(indent) << m_reserveGroup << '\n';
8074   strm << setw(indent+16) << "propertyParms = " << setprecision(indent) << m_propertyParms << '\n';
8075   strm << setw(indent-1) << setprecision(indent-2) << "}";
8076 }
8077 #endif
8078
8079
8080 PObject::Comparison H248_LocalControlDescriptor::Compare(const PObject & obj) const
8081 {
8082 #ifndef PASN_LEANANDMEAN
8083   PAssert(PIsDescendant(&obj, H248_LocalControlDescriptor), PInvalidCast);
8084 #endif
8085   const H248_LocalControlDescriptor & other = (const H248_LocalControlDescriptor &)obj;
8086
8087   Comparison result;
8088
8089   if ((result = m_streamMode.Compare(other.m_streamMode)) != EqualTo)
8090     return result;
8091   if ((result = m_reserveValue.Compare(other.m_reserveValue)) != EqualTo)
8092     return result;
8093   if ((result = m_reserveGroup.Compare(other.m_reserveGroup)) != EqualTo)
8094     return result;
8095   if ((result = m_propertyParms.Compare(other.m_propertyParms)) != EqualTo)
8096     return result;
8097
8098   return PASN_Sequence::Compare(other);
8099 }
8100
8101
8102 PINDEX H248_LocalControlDescriptor::GetDataLength() const
8103 {
8104   PINDEX length = 0;
8105   if (HasOptionalField(e_streamMode))
8106     length += m_streamMode.GetObjectLength();
8107   if (HasOptionalField(e_reserveValue))
8108     length += m_reserveValue.GetObjectLength();
8109   if (HasOptionalField(e_reserveGroup))
8110     length += m_reserveGroup.GetObjectLength();
8111   length += m_propertyParms.GetObjectLength();
8112   return length;
8113 }
8114
8115
8116 BOOL H248_LocalControlDescriptor::Decode(PASN_Stream & strm)
8117 {
8118   if (!PreambleDecode(strm))
8119     return FALSE;
8120
8121   if (HasOptionalField(e_streamMode) && !m_streamMode.Decode(strm))
8122     return FALSE;
8123   if (HasOptionalField(e_reserveValue) && !m_reserveValue.Decode(strm))
8124     return FALSE;
8125   if (HasOptionalField(e_reserveGroup) && !m_reserveGroup.Decode(strm))
8126     return FALSE;
8127   if (!m_propertyParms.Decode(strm))
8128     return FALSE;
8129
8130   return UnknownExtensionsDecode(strm);
8131 }
8132
8133
8134 void H248_LocalControlDescriptor::Encode(PASN_Stream & strm) const
8135 {
8136   PreambleEncode(strm);
8137
8138   if (HasOptionalField(e_streamMode))
8139     m_streamMode.Encode(strm);
8140   if (HasOptionalField(e_reserveValue))
8141     m_reserveValue.Encode(strm);
8142   if (HasOptionalField(e_reserveGroup))
8143     m_reserveGroup.Encode(strm);
8144   m_propertyParms.Encode(strm);
8145
8146   UnknownExtensionsEncode(strm);
8147 }
8148
8149
8150 PObject * H248_LocalControlDescriptor::Clone() const
8151 {
8152 #ifndef PASN_LEANANDMEAN
8153   PAssert(IsClass(H248_LocalControlDescriptor::Class()), PInvalidCast);
8154 #endif
8155   return new H248_LocalControlDescriptor(*this);
8156 }
8157
8158
8159 //
8160 // PropertyParm
8161 //
8162
8163 H248_PropertyParm::H248_PropertyParm(unsigned tag, PASN_Object::TagClass tagClass)
8164   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
8165 {
8166 }
8167
8168
8169 #ifndef PASN_NOPRINTON
8170 void H248_PropertyParm::PrintOn(ostream & strm) const
8171 {
8172   int indent = strm.precision() + 2;
8173   strm << "{\n";
8174   strm << setw(indent+7) << "name = " << setprecision(indent) << m_name << '\n';
8175   strm << setw(indent+8) << "value = " << setprecision(indent) << m_value << '\n';
8176   if (HasOptionalField(e_extraInfo))
8177     strm << setw(indent+12) << "extraInfo = " << setprecision(indent) << m_extraInfo << '\n';
8178   strm << setw(indent-1) << setprecision(indent-2) << "}";
8179 }
8180 #endif
8181
8182
8183 PObject::Comparison H248_PropertyParm::Compare(const PObject & obj) const
8184 {
8185 #ifndef PASN_LEANANDMEAN
8186   PAssert(PIsDescendant(&obj, H248_PropertyParm), PInvalidCast);
8187 #endif
8188   const H248_PropertyParm & other = (const H248_PropertyParm &)obj;
8189
8190   Comparison result;
8191
8192   if ((result = m_name.Compare(other.m_name)) != EqualTo)
8193     return result;
8194   if ((result = m_value.Compare(other.m_value)) != EqualTo)
8195     return result;
8196   if ((result = m_extraInfo.Compare(other.m_extraInfo)) != EqualTo)
8197     return result;
8198
8199   return PASN_Sequence::Compare(other);
8200 }
8201
8202
8203 PINDEX H248_PropertyParm::GetDataLength() const
8204 {
8205   PINDEX length = 0;
8206   length += m_name.GetObjectLength();
8207   length += m_value.GetObjectLength();
8208   if (HasOptionalField(e_extraInfo))
8209     length += m_extraInfo.GetObjectLength();
8210   return length;
8211 }
8212
8213
8214 BOOL H248_PropertyParm::Decode(PASN_Stream & strm)
8215 {
8216   if (!PreambleDecode(strm))
8217     return FALSE;
8218
8219   if (!m_name.Decode(strm))
8220     return FALSE;
8221   if (!m_value.Decode(strm))
8222     return FALSE;
8223   if (HasOptionalField(e_extraInfo) && !m_extraInfo.Decode(strm))
8224     return FALSE;
8225
8226   return UnknownExtensionsDecode(strm);
8227 }
8228
8229
8230 void H248_PropertyParm::Encode(PASN_Stream & strm) const
8231 {
8232   PreambleEncode(strm);
8233
8234   m_name.Encode(strm);
8235   m_value.Encode(strm);
8236   if (HasOptionalField(e_extraInfo))
8237     m_extraInfo.Encode(strm);
8238
8239   UnknownExtensionsEncode(strm);
8240 }
8241
8242
8243 PObject * H248_PropertyParm::Clone() const
8244 {
8245 #ifndef PASN_LEANANDMEAN
8246   PAssert(IsClass(H248_PropertyParm::Class()), PInvalidCast);
8247 #endif
8248   return new H248_PropertyParm(*this);
8249 }
8250
8251
8252 //
8253 // LocalRemoteDescriptor
8254 //
8255
8256 H248_LocalRemoteDescriptor::H248_LocalRemoteDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
8257   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
8258 {
8259 }
8260
8261
8262 #ifndef PASN_NOPRINTON
8263 void H248_LocalRemoteDescriptor::PrintOn(ostream & strm) const
8264 {
8265   int indent = strm.precision() + 2;
8266   strm << "{\n";
8267   strm << setw(indent+11) << "propGrps = " << setprecision(indent) << m_propGrps << '\n';
8268   strm << setw(indent-1) << setprecision(indent-2) << "}";
8269 }
8270 #endif
8271
8272
8273 PObject::Comparison H248_LocalRemoteDescriptor::Compare(const PObject & obj) const
8274 {
8275 #ifndef PASN_LEANANDMEAN
8276   PAssert(PIsDescendant(&obj, H248_LocalRemoteDescriptor), PInvalidCast);
8277 #endif
8278   const H248_LocalRemoteDescriptor & other = (const H248_LocalRemoteDescriptor &)obj;
8279
8280   Comparison result;
8281
8282   if ((result = m_propGrps.Compare(other.m_propGrps)) != EqualTo)
8283     return result;
8284
8285   return PASN_Sequence::Compare(other);
8286 }
8287
8288
8289 PINDEX H248_LocalRemoteDescriptor::GetDataLength() const
8290 {
8291   PINDEX length = 0;
8292   length += m_propGrps.GetObjectLength();
8293   return length;
8294 }
8295
8296
8297 BOOL H248_LocalRemoteDescriptor::Decode(PASN_Stream & strm)
8298 {
8299   if (!PreambleDecode(strm))
8300     return FALSE;
8301
8302   if (!m_propGrps.Decode(strm))
8303     return FALSE;
8304
8305   return UnknownExtensionsDecode(strm);
8306 }
8307
8308
8309 void H248_LocalRemoteDescriptor::Encode(PASN_Stream & strm) const
8310 {
8311   PreambleEncode(strm);
8312
8313   m_propGrps.Encode(strm);
8314
8315   UnknownExtensionsEncode(strm);
8316 }
8317
8318
8319 PObject * H248_LocalRemoteDescriptor::Clone() const
8320 {
8321 #ifndef PASN_LEANANDMEAN
8322   PAssert(IsClass(H248_LocalRemoteDescriptor::Class()), PInvalidCast);
8323 #endif
8324   return new H248_LocalRemoteDescriptor(*this);
8325 }
8326
8327
8328 //
8329 // TerminationStateDescriptor
8330 //
8331
8332 H248_TerminationStateDescriptor::H248_TerminationStateDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
8333   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
8334 {
8335 }
8336
8337
8338 #ifndef PASN_NOPRINTON
8339 void H248_TerminationStateDescriptor::PrintOn(ostream & strm) const
8340 {
8341   int indent = strm.precision() + 2;
8342   strm << "{\n";
8343   strm << setw(indent+16) << "propertyParms = " << setprecision(indent) << m_propertyParms << '\n';
8344   if (HasOptionalField(e_eventBufferControl))
8345     strm << setw(indent+21) << "eventBufferControl = " << setprecision(indent) << m_eventBufferControl << '\n';
8346   if (HasOptionalField(e_serviceState))
8347     strm << setw(indent+15) << "serviceState = " << setprecision(indent) << m_serviceState << '\n';
8348   strm << setw(indent-1) << setprecision(indent-2) << "}";
8349 }
8350 #endif
8351
8352
8353 PObject::Comparison H248_TerminationStateDescriptor::Compare(const PObject & obj) const
8354 {
8355 #ifndef PASN_LEANANDMEAN
8356   PAssert(PIsDescendant(&obj, H248_TerminationStateDescriptor), PInvalidCast);
8357 #endif
8358   const H248_TerminationStateDescriptor & other = (const H248_TerminationStateDescriptor &)obj;
8359
8360   Comparison result;
8361
8362   if ((result = m_propertyParms.Compare(other.m_propertyParms)) != EqualTo)
8363     return result;
8364   if ((result = m_eventBufferControl.Compare(other.m_eventBufferControl)) != EqualTo)
8365     return result;
8366   if ((result = m_serviceState.Compare(other.m_serviceState)) != EqualTo)
8367     return result;
8368
8369   return PASN_Sequence::Compare(other);
8370 }
8371
8372
8373 PINDEX H248_TerminationStateDescriptor::GetDataLength() const
8374 {
8375   PINDEX length = 0;
8376   length += m_propertyParms.GetObjectLength();
8377   if (HasOptionalField(e_eventBufferControl))
8378     length += m_eventBufferControl.GetObjectLength();
8379   if (HasOptionalField(e_serviceState))
8380     length += m_serviceState.GetObjectLength();
8381   return length;
8382 }
8383
8384
8385 BOOL H248_TerminationStateDescriptor::Decode(PASN_Stream & strm)
8386 {
8387   if (!PreambleDecode(strm))
8388     return FALSE;
8389
8390   if (!m_propertyParms.Decode(strm))
8391     return FALSE;
8392   if (HasOptionalField(e_eventBufferControl) && !m_eventBufferControl.Decode(strm))
8393     return FALSE;
8394   if (HasOptionalField(e_serviceState) && !m_serviceState.Decode(strm))
8395     return FALSE;
8396
8397   return UnknownExtensionsDecode(strm);
8398 }
8399
8400
8401 void H248_TerminationStateDescriptor::Encode(PASN_Stream & strm) const
8402 {
8403   PreambleEncode(strm);
8404
8405   m_propertyParms.Encode(strm);
8406   if (HasOptionalField(e_eventBufferControl))
8407     m_eventBufferControl.Encode(strm);
8408   if (HasOptionalField(e_serviceState))
8409     m_serviceState.Encode(strm);
8410
8411   UnknownExtensionsEncode(strm);
8412 }
8413
8414
8415 PObject * H248_TerminationStateDescriptor::Clone() const
8416 {
8417 #ifndef PASN_LEANANDMEAN
8418   PAssert(IsClass(H248_TerminationStateDescriptor::Class()), PInvalidCast);
8419 #endif
8420   return new H248_TerminationStateDescriptor(*this);
8421 }
8422
8423
8424 //
8425 // EventsDescriptor
8426 //
8427
8428 H248_EventsDescriptor::H248_EventsDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
8429   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
8430 {
8431 }
8432
8433
8434 #ifndef PASN_NOPRINTON
8435 void H248_EventsDescriptor::PrintOn(ostream & strm) const
8436 {
8437   int indent = strm.precision() + 2;
8438   strm << "{\n";
8439   if (HasOptionalField(e_requestID))
8440     strm << setw(indent+12) << "requestID = " << setprecision(indent) << m_requestID << '\n';
8441   strm << setw(indent+12) << "eventList = " << setprecision(indent) << m_eventList << '\n';
8442   strm << setw(indent-1) << setprecision(indent-2) << "}";
8443 }
8444 #endif
8445
8446
8447 PObject::Comparison H248_EventsDescriptor::Compare(const PObject & obj) const
8448 {
8449 #ifndef PASN_LEANANDMEAN
8450   PAssert(PIsDescendant(&obj, H248_EventsDescriptor), PInvalidCast);
8451 #endif
8452   const H248_EventsDescriptor & other = (const H248_EventsDescriptor &)obj;
8453
8454   Comparison result;
8455
8456   if ((result = m_requestID.Compare(other.m_requestID)) != EqualTo)
8457     return result;
8458   if ((result = m_eventList.Compare(other.m_eventList)) != EqualTo)
8459     return result;
8460
8461   return PASN_Sequence::Compare(other);
8462 }
8463
8464
8465 PINDEX H248_EventsDescriptor::GetDataLength() const
8466 {
8467   PINDEX length = 0;
8468   if (HasOptionalField(e_requestID))
8469     length += m_requestID.GetObjectLength();
8470   length += m_eventList.GetObjectLength();
8471   return length;
8472 }
8473
8474
8475 BOOL H248_EventsDescriptor::Decode(PASN_Stream & strm)
8476 {
8477   if (!PreambleDecode(strm))
8478     return FALSE;
8479
8480   if (HasOptionalField(e_requestID) && !m_requestID.Decode(strm))
8481     return FALSE;
8482   if (!m_eventList.Decode(strm))
8483     return FALSE;
8484
8485   return UnknownExtensionsDecode(strm);
8486 }
8487
8488
8489 void H248_EventsDescriptor::Encode(PASN_Stream & strm) const
8490 {
8491   PreambleEncode(strm);
8492
8493   if (HasOptionalField(e_requestID))
8494     m_requestID.Encode(strm);
8495   m_eventList.Encode(strm);
8496
8497   UnknownExtensionsEncode(strm);
8498 }
8499
8500
8501 PObject * H248_EventsDescriptor::Clone() const
8502 {
8503 #ifndef PASN_LEANANDMEAN
8504   PAssert(IsClass(H248_EventsDescriptor::Class()), PInvalidCast);
8505 #endif
8506   return new H248_EventsDescriptor(*this);
8507 }
8508
8509
8510 //
8511 // SecondEventsDescriptor
8512 //
8513
8514 H248_SecondEventsDescriptor::H248_SecondEventsDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
8515   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
8516 {
8517 }
8518
8519
8520 #ifndef PASN_NOPRINTON
8521 void H248_SecondEventsDescriptor::PrintOn(ostream & strm) const
8522 {
8523   int indent = strm.precision() + 2;
8524   strm << "{\n";
8525   if (HasOptionalField(e_requestID))
8526     strm << setw(indent+12) << "requestID = " << setprecision(indent) << m_requestID << '\n';
8527   strm << setw(indent+12) << "eventList = " << setprecision(indent) << m_eventList << '\n';
8528   strm << setw(indent-1) << setprecision(indent-2) << "}";
8529 }
8530 #endif
8531
8532
8533 PObject::Comparison H248_SecondEventsDescriptor::Compare(const PObject & obj) const
8534 {
8535 #ifndef PASN_LEANANDMEAN
8536   PAssert(PIsDescendant(&obj, H248_SecondEventsDescriptor), PInvalidCast);
8537 #endif
8538   const H248_SecondEventsDescriptor & other = (const H248_SecondEventsDescriptor &)obj;
8539
8540   Comparison result;
8541
8542   if ((result = m_requestID.Compare(other.m_requestID)) != EqualTo)
8543     return result;
8544   if ((result = m_eventList.Compare(other.m_eventList)) != EqualTo)
8545     return result;
8546
8547   return PASN_Sequence::Compare(other);
8548 }
8549
8550
8551 PINDEX H248_SecondEventsDescriptor::GetDataLength() const
8552 {
8553   PINDEX length = 0;
8554   if (HasOptionalField(e_requestID))
8555     length += m_requestID.GetObjectLength();
8556   length += m_eventList.GetObjectLength();
8557   return length;
8558 }
8559
8560
8561 BOOL H248_SecondEventsDescriptor::Decode(PASN_Stream & strm)
8562 {
8563   if (!PreambleDecode(strm))
8564     return FALSE;
8565
8566   if (HasOptionalField(e_requestID) && !m_requestID.Decode(strm))
8567     return FALSE;
8568   if (!m_eventList.Decode(strm))
8569     return FALSE;
8570
8571   return UnknownExtensionsDecode(strm);
8572 }
8573
8574
8575 void H248_SecondEventsDescriptor::Encode(PASN_Stream & strm) const
8576 {
8577   PreambleEncode(strm);
8578
8579   if (HasOptionalField(e_requestID))
8580     m_requestID.Encode(strm);
8581   m_eventList.Encode(strm);
8582
8583   UnknownExtensionsEncode(strm);
8584 }
8585
8586
8587 PObject * H248_SecondEventsDescriptor::Clone() const
8588 {
8589 #ifndef PASN_LEANANDMEAN
8590   PAssert(IsClass(H248_SecondEventsDescriptor::Class()), PInvalidCast);
8591 #endif
8592   return new H248_SecondEventsDescriptor(*this);
8593 }
8594
8595
8596 //
8597 // SecondRequestedActions
8598 //
8599
8600 H248_SecondRequestedActions::H248_SecondRequestedActions(unsigned tag, PASN_Object::TagClass tagClass)
8601   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
8602 {
8603 }
8604
8605
8606 #ifndef PASN_NOPRINTON
8607 void H248_SecondRequestedActions::PrintOn(ostream & strm) const
8608 {
8609   int indent = strm.precision() + 2;
8610   strm << "{\n";
8611   if (HasOptionalField(e_keepActive))
8612     strm << setw(indent+13) << "keepActive = " << setprecision(indent) << m_keepActive << '\n';
8613   if (HasOptionalField(e_eventDM))
8614     strm << setw(indent+10) << "eventDM = " << setprecision(indent) << m_eventDM << '\n';
8615   if (HasOptionalField(e_signalsDescriptor))
8616     strm << setw(indent+20) << "signalsDescriptor = " << setprecision(indent) << m_signalsDescriptor << '\n';
8617   strm << setw(indent-1) << setprecision(indent-2) << "}";
8618 }
8619 #endif
8620
8621
8622 PObject::Comparison H248_SecondRequestedActions::Compare(const PObject & obj) const
8623 {
8624 #ifndef PASN_LEANANDMEAN
8625   PAssert(PIsDescendant(&obj, H248_SecondRequestedActions), PInvalidCast);
8626 #endif
8627   const H248_SecondRequestedActions & other = (const H248_SecondRequestedActions &)obj;
8628
8629   Comparison result;
8630
8631   if ((result = m_keepActive.Compare(other.m_keepActive)) != EqualTo)
8632     return result;
8633   if ((result = m_eventDM.Compare(other.m_eventDM)) != EqualTo)
8634     return result;
8635   if ((result = m_signalsDescriptor.Compare(other.m_signalsDescriptor)) != EqualTo)
8636     return result;
8637
8638   return PASN_Sequence::Compare(other);
8639 }
8640
8641
8642 PINDEX H248_SecondRequestedActions::GetDataLength() const
8643 {
8644   PINDEX length = 0;
8645   if (HasOptionalField(e_keepActive))
8646     length += m_keepActive.GetObjectLength();
8647   if (HasOptionalField(e_eventDM))
8648     length += m_eventDM.GetObjectLength();
8649   if (HasOptionalField(e_signalsDescriptor))
8650     length += m_signalsDescriptor.GetObjectLength();
8651   return length;
8652 }
8653
8654
8655 BOOL H248_SecondRequestedActions::Decode(PASN_Stream & strm)
8656 {
8657   if (!PreambleDecode(strm))
8658     return FALSE;
8659
8660   if (HasOptionalField(e_keepActive) && !m_keepActive.Decode(strm))
8661     return FALSE;
8662   if (HasOptionalField(e_eventDM) && !m_eventDM.Decode(strm))
8663     return FALSE;
8664   if (HasOptionalField(e_signalsDescriptor) && !m_signalsDescriptor.Decode(strm))
8665     return FALSE;
8666
8667   return UnknownExtensionsDecode(strm);
8668 }
8669
8670
8671 void H248_SecondRequestedActions::Encode(PASN_Stream & strm) const
8672 {
8673   PreambleEncode(strm);
8674
8675   if (HasOptionalField(e_keepActive))
8676     m_keepActive.Encode(strm);
8677   if (HasOptionalField(e_eventDM))
8678     m_eventDM.Encode(strm);
8679   if (HasOptionalField(e_signalsDescriptor))
8680     m_signalsDescriptor.Encode(strm);
8681
8682   UnknownExtensionsEncode(strm);
8683 }
8684
8685
8686 PObject * H248_SecondRequestedActions::Clone() const
8687 {
8688 #ifndef PASN_LEANANDMEAN
8689   PAssert(IsClass(H248_SecondRequestedActions::Class()), PInvalidCast);
8690 #endif
8691   return new H248_SecondRequestedActions(*this);
8692 }
8693
8694
8695 //
8696 // EventSpec
8697 //
8698
8699 H248_EventSpec::H248_EventSpec(unsigned tag, PASN_Object::TagClass tagClass)
8700   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
8701 {
8702 }
8703
8704
8705 #ifndef PASN_NOPRINTON
8706 void H248_EventSpec::PrintOn(ostream & strm) const
8707 {
8708   int indent = strm.precision() + 2;
8709   strm << "{\n";
8710   strm << setw(indent+12) << "eventName = " << setprecision(indent) << m_eventName << '\n';
8711   if (HasOptionalField(e_streamID))
8712     strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
8713   strm << setw(indent+15) << "eventParList = " << setprecision(indent) << m_eventParList << '\n';
8714   strm << setw(indent-1) << setprecision(indent-2) << "}";
8715 }
8716 #endif
8717
8718
8719 PObject::Comparison H248_EventSpec::Compare(const PObject & obj) const
8720 {
8721 #ifndef PASN_LEANANDMEAN
8722   PAssert(PIsDescendant(&obj, H248_EventSpec), PInvalidCast);
8723 #endif
8724   const H248_EventSpec & other = (const H248_EventSpec &)obj;
8725
8726   Comparison result;
8727
8728   if ((result = m_eventName.Compare(other.m_eventName)) != EqualTo)
8729     return result;
8730   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
8731     return result;
8732   if ((result = m_eventParList.Compare(other.m_eventParList)) != EqualTo)
8733     return result;
8734
8735   return PASN_Sequence::Compare(other);
8736 }
8737
8738
8739 PINDEX H248_EventSpec::GetDataLength() const
8740 {
8741   PINDEX length = 0;
8742   length += m_eventName.GetObjectLength();
8743   if (HasOptionalField(e_streamID))
8744     length += m_streamID.GetObjectLength();
8745   length += m_eventParList.GetObjectLength();
8746   return length;
8747 }
8748
8749
8750 BOOL H248_EventSpec::Decode(PASN_Stream & strm)
8751 {
8752   if (!PreambleDecode(strm))
8753     return FALSE;
8754
8755   if (!m_eventName.Decode(strm))
8756     return FALSE;
8757   if (HasOptionalField(e_streamID) && !m_streamID.Decode(strm))
8758     return FALSE;
8759   if (!m_eventParList.Decode(strm))
8760     return FALSE;
8761
8762   return UnknownExtensionsDecode(strm);
8763 }
8764
8765
8766 void H248_EventSpec::Encode(PASN_Stream & strm) const
8767 {
8768   PreambleEncode(strm);
8769
8770   m_eventName.Encode(strm);
8771   if (HasOptionalField(e_streamID))
8772     m_streamID.Encode(strm);
8773   m_eventParList.Encode(strm);
8774
8775   UnknownExtensionsEncode(strm);
8776 }
8777
8778
8779 PObject * H248_EventSpec::Clone() const
8780 {
8781 #ifndef PASN_LEANANDMEAN
8782   PAssert(IsClass(H248_EventSpec::Class()), PInvalidCast);
8783 #endif
8784   return new H248_EventSpec(*this);
8785 }
8786
8787
8788 //
8789 // SeqSigList
8790 //
8791
8792 H248_SeqSigList::H248_SeqSigList(unsigned tag, PASN_Object::TagClass tagClass)
8793   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
8794 {
8795   m_id.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
8796 }
8797
8798
8799 #ifndef PASN_NOPRINTON
8800 void H248_SeqSigList::PrintOn(ostream & strm) const
8801 {
8802   int indent = strm.precision() + 2;
8803   strm << "{\n";
8804   strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
8805   strm << setw(indent+13) << "signalList = " << setprecision(indent) << m_signalList << '\n';
8806   strm << setw(indent-1) << setprecision(indent-2) << "}";
8807 }
8808 #endif
8809
8810
8811 PObject::Comparison H248_SeqSigList::Compare(const PObject & obj) const
8812 {
8813 #ifndef PASN_LEANANDMEAN
8814   PAssert(PIsDescendant(&obj, H248_SeqSigList), PInvalidCast);
8815 #endif
8816   const H248_SeqSigList & other = (const H248_SeqSigList &)obj;
8817
8818   Comparison result;
8819
8820   if ((result = m_id.Compare(other.m_id)) != EqualTo)
8821     return result;
8822   if ((result = m_signalList.Compare(other.m_signalList)) != EqualTo)
8823     return result;
8824
8825   return PASN_Sequence::Compare(other);
8826 }
8827
8828
8829 PINDEX H248_SeqSigList::GetDataLength() const
8830 {
8831   PINDEX length = 0;
8832   length += m_id.GetObjectLength();
8833   length += m_signalList.GetObjectLength();
8834   return length;
8835 }
8836
8837
8838 BOOL H248_SeqSigList::Decode(PASN_Stream & strm)
8839 {
8840   if (!PreambleDecode(strm))
8841     return FALSE;
8842
8843   if (!m_id.Decode(strm))
8844     return FALSE;
8845   if (!m_signalList.Decode(strm))
8846     return FALSE;
8847
8848   return UnknownExtensionsDecode(strm);
8849 }
8850
8851
8852 void H248_SeqSigList::Encode(PASN_Stream & strm) const
8853 {
8854   PreambleEncode(strm);
8855
8856   m_id.Encode(strm);
8857   m_signalList.Encode(strm);
8858
8859   UnknownExtensionsEncode(strm);
8860 }
8861
8862
8863 PObject * H248_SeqSigList::Clone() const
8864 {
8865 #ifndef PASN_LEANANDMEAN
8866   PAssert(IsClass(H248_SeqSigList::Class()), PInvalidCast);
8867 #endif
8868   return new H248_SeqSigList(*this);
8869 }
8870
8871
8872 //
8873 // Signal
8874 //
8875
8876 H248_Signal::H248_Signal(unsigned tag, PASN_Object::TagClass tagClass)
8877   : PASN_Sequence(tag, tagClass, 5, TRUE, 0)
8878 {
8879   m_duration.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
8880 }
8881
8882
8883 #ifndef PASN_NOPRINTON
8884 void H248_Signal::PrintOn(ostream & strm) const
8885 {
8886   int indent = strm.precision() + 2;
8887   strm << "{\n";
8888   strm << setw(indent+13) << "signalName = " << setprecision(indent) << m_signalName << '\n';
8889   if (HasOptionalField(e_streamID))
8890     strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
8891   if (HasOptionalField(e_sigType))
8892     strm << setw(indent+10) << "sigType = " << setprecision(indent) << m_sigType << '\n';
8893   if (HasOptionalField(e_duration))
8894     strm << setw(indent+11) << "duration = " << setprecision(indent) << m_duration << '\n';
8895   if (HasOptionalField(e_notifyCompletion))
8896     strm << setw(indent+19) << "notifyCompletion = " << setprecision(indent) << m_notifyCompletion << '\n';
8897   if (HasOptionalField(e_keepActive))
8898     strm << setw(indent+13) << "keepActive = " << setprecision(indent) << m_keepActive << '\n';
8899   strm << setw(indent+13) << "sigParList = " << setprecision(indent) << m_sigParList << '\n';
8900   strm << setw(indent-1) << setprecision(indent-2) << "}";
8901 }
8902 #endif
8903
8904
8905 PObject::Comparison H248_Signal::Compare(const PObject & obj) const
8906 {
8907 #ifndef PASN_LEANANDMEAN
8908   PAssert(PIsDescendant(&obj, H248_Signal), PInvalidCast);
8909 #endif
8910   const H248_Signal & other = (const H248_Signal &)obj;
8911
8912   Comparison result;
8913
8914   if ((result = m_signalName.Compare(other.m_signalName)) != EqualTo)
8915     return result;
8916   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
8917     return result;
8918   if ((result = m_sigType.Compare(other.m_sigType)) != EqualTo)
8919     return result;
8920   if ((result = m_duration.Compare(other.m_duration)) != EqualTo)
8921     return result;
8922   if ((result = m_notifyCompletion.Compare(other.m_notifyCompletion)) != EqualTo)
8923     return result;
8924   if ((result = m_keepActive.Compare(other.m_keepActive)) != EqualTo)
8925     return result;
8926   if ((result = m_sigParList.Compare(other.m_sigParList)) != EqualTo)
8927     return result;
8928
8929   return PASN_Sequence::Compare(other);
8930 }
8931
8932
8933 PINDEX H248_Signal::GetDataLength() const
8934 {
8935   PINDEX length = 0;
8936   length += m_signalName.GetObjectLength();
8937   if (HasOptionalField(e_streamID))
8938     length += m_streamID.GetObjectLength();
8939   if (HasOptionalField(e_sigType))
8940     length += m_sigType.GetObjectLength();
8941   if (HasOptionalField(e_duration))
8942     length += m_duration.GetObjectLength();
8943   if (HasOptionalField(e_notifyCompletion))
8944     length += m_notifyCompletion.GetObjectLength();
8945   if (HasOptionalField(e_keepActive))
8946     length += m_keepActive.GetObjectLength();
8947   length += m_sigParList.GetObjectLength();
8948   return length;
8949 }
8950
8951
8952 BOOL H248_Signal::Decode(PASN_Stream & strm)
8953 {
8954   if (!PreambleDecode(strm))
8955     return FALSE;
8956
8957   if (!m_signalName.Decode(strm))
8958     return FALSE;
8959   if (HasOptionalField(e_streamID) && !m_streamID.Decode(strm))
8960     return FALSE;
8961   if (HasOptionalField(e_sigType) && !m_sigType.Decode(strm))
8962     return FALSE;
8963   if (HasOptionalField(e_duration) && !m_duration.Decode(strm))
8964     return FALSE;
8965   if (HasOptionalField(e_notifyCompletion) && !m_notifyCompletion.Decode(strm))
8966     return FALSE;
8967   if (HasOptionalField(e_keepActive) && !m_keepActive.Decode(strm))
8968     return FALSE;
8969   if (!m_sigParList.Decode(strm))
8970     return FALSE;
8971
8972   return UnknownExtensionsDecode(strm);
8973 }
8974
8975
8976 void H248_Signal::Encode(PASN_Stream & strm) const
8977 {
8978   PreambleEncode(strm);
8979
8980   m_signalName.Encode(strm);
8981   if (HasOptionalField(e_streamID))
8982     m_streamID.Encode(strm);
8983   if (HasOptionalField(e_sigType))
8984     m_sigType.Encode(strm);
8985   if (HasOptionalField(e_duration))
8986     m_duration.Encode(strm);
8987   if (HasOptionalField(e_notifyCompletion))
8988     m_notifyCompletion.Encode(strm);
8989   if (HasOptionalField(e_keepActive))
8990     m_keepActive.Encode(strm);
8991   m_sigParList.Encode(strm);
8992
8993   UnknownExtensionsEncode(strm);
8994 }
8995
8996
8997 PObject * H248_Signal::Clone() const
8998 {
8999 #ifndef PASN_LEANANDMEAN
9000   PAssert(IsClass(H248_Signal::Class()), PInvalidCast);
9001 #endif
9002   return new H248_Signal(*this);
9003 }
9004
9005
9006 //
9007 // SigParameter
9008 //
9009
9010 H248_SigParameter::H248_SigParameter(unsigned tag, PASN_Object::TagClass tagClass)
9011   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
9012 {
9013 }
9014
9015
9016 #ifndef PASN_NOPRINTON
9017 void H248_SigParameter::PrintOn(ostream & strm) const
9018 {
9019   int indent = strm.precision() + 2;
9020   strm << "{\n";
9021   strm << setw(indent+19) << "sigParameterName = " << setprecision(indent) << m_sigParameterName << '\n';
9022   strm << setw(indent+8) << "value = " << setprecision(indent) << m_value << '\n';
9023   if (HasOptionalField(e_extraInfo))
9024     strm << setw(indent+12) << "extraInfo = " << setprecision(indent) << m_extraInfo << '\n';
9025   strm << setw(indent-1) << setprecision(indent-2) << "}";
9026 }
9027 #endif
9028
9029
9030 PObject::Comparison H248_SigParameter::Compare(const PObject & obj) const
9031 {
9032 #ifndef PASN_LEANANDMEAN
9033   PAssert(PIsDescendant(&obj, H248_SigParameter), PInvalidCast);
9034 #endif
9035   const H248_SigParameter & other = (const H248_SigParameter &)obj;
9036
9037   Comparison result;
9038
9039   if ((result = m_sigParameterName.Compare(other.m_sigParameterName)) != EqualTo)
9040     return result;
9041   if ((result = m_value.Compare(other.m_value)) != EqualTo)
9042     return result;
9043   if ((result = m_extraInfo.Compare(other.m_extraInfo)) != EqualTo)
9044     return result;
9045
9046   return PASN_Sequence::Compare(other);
9047 }
9048
9049
9050 PINDEX H248_SigParameter::GetDataLength() const
9051 {
9052   PINDEX length = 0;
9053   length += m_sigParameterName.GetObjectLength();
9054   length += m_value.GetObjectLength();
9055   if (HasOptionalField(e_extraInfo))
9056     length += m_extraInfo.GetObjectLength();
9057   return length;
9058 }
9059
9060
9061 BOOL H248_SigParameter::Decode(PASN_Stream & strm)
9062 {
9063   if (!PreambleDecode(strm))
9064     return FALSE;
9065
9066   if (!m_sigParameterName.Decode(strm))
9067     return FALSE;
9068   if (!m_value.Decode(strm))
9069     return FALSE;
9070   if (HasOptionalField(e_extraInfo) && !m_extraInfo.Decode(strm))
9071     return FALSE;
9072
9073   return UnknownExtensionsDecode(strm);
9074 }
9075
9076
9077 void H248_SigParameter::Encode(PASN_Stream & strm) const
9078 {
9079   PreambleEncode(strm);
9080
9081   m_sigParameterName.Encode(strm);
9082   m_value.Encode(strm);
9083   if (HasOptionalField(e_extraInfo))
9084     m_extraInfo.Encode(strm);
9085
9086   UnknownExtensionsEncode(strm);
9087 }
9088
9089
9090 PObject * H248_SigParameter::Clone() const
9091 {
9092 #ifndef PASN_LEANANDMEAN
9093   PAssert(IsClass(H248_SigParameter::Class()), PInvalidCast);
9094 #endif
9095   return new H248_SigParameter(*this);
9096 }
9097
9098
9099 //
9100 // DigitMapDescriptor
9101 //
9102
9103 H248_DigitMapDescriptor::H248_DigitMapDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
9104   : PASN_Sequence(tag, tagClass, 2, FALSE, 0)
9105 {
9106 }
9107
9108
9109 #ifndef PASN_NOPRINTON
9110 void H248_DigitMapDescriptor::PrintOn(ostream & strm) const
9111 {
9112   int indent = strm.precision() + 2;
9113   strm << "{\n";
9114   if (HasOptionalField(e_digitMapName))
9115     strm << setw(indent+15) << "digitMapName = " << setprecision(indent) << m_digitMapName << '\n';
9116   if (HasOptionalField(e_digitMapValue))
9117     strm << setw(indent+16) << "digitMapValue = " << setprecision(indent) << m_digitMapValue << '\n';
9118   strm << setw(indent-1) << setprecision(indent-2) << "}";
9119 }
9120 #endif
9121
9122
9123 PObject::Comparison H248_DigitMapDescriptor::Compare(const PObject & obj) const
9124 {
9125 #ifndef PASN_LEANANDMEAN
9126   PAssert(PIsDescendant(&obj, H248_DigitMapDescriptor), PInvalidCast);
9127 #endif
9128   const H248_DigitMapDescriptor & other = (const H248_DigitMapDescriptor &)obj;
9129
9130   Comparison result;
9131
9132   if ((result = m_digitMapName.Compare(other.m_digitMapName)) != EqualTo)
9133     return result;
9134   if ((result = m_digitMapValue.Compare(other.m_digitMapValue)) != EqualTo)
9135     return result;
9136
9137   return PASN_Sequence::Compare(other);
9138 }
9139
9140
9141 PINDEX H248_DigitMapDescriptor::GetDataLength() const
9142 {
9143   PINDEX length = 0;
9144   if (HasOptionalField(e_digitMapName))
9145     length += m_digitMapName.GetObjectLength();
9146   if (HasOptionalField(e_digitMapValue))
9147     length += m_digitMapValue.GetObjectLength();
9148   return length;
9149 }
9150
9151
9152 BOOL H248_DigitMapDescriptor::Decode(PASN_Stream & strm)
9153 {
9154   if (!PreambleDecode(strm))
9155     return FALSE;
9156
9157   if (HasOptionalField(e_digitMapName) && !m_digitMapName.Decode(strm))
9158     return FALSE;
9159   if (HasOptionalField(e_digitMapValue) && !m_digitMapValue.Decode(strm))
9160     return FALSE;
9161
9162   return UnknownExtensionsDecode(strm);
9163 }
9164
9165
9166 void H248_DigitMapDescriptor::Encode(PASN_Stream & strm) const
9167 {
9168   PreambleEncode(strm);
9169
9170   if (HasOptionalField(e_digitMapName))
9171     m_digitMapName.Encode(strm);
9172   if (HasOptionalField(e_digitMapValue))
9173     m_digitMapValue.Encode(strm);
9174
9175   UnknownExtensionsEncode(strm);
9176 }
9177
9178
9179 PObject * H248_DigitMapDescriptor::Clone() const
9180 {
9181 #ifndef PASN_LEANANDMEAN
9182   PAssert(IsClass(H248_DigitMapDescriptor::Class()), PInvalidCast);
9183 #endif
9184   return new H248_DigitMapDescriptor(*this);
9185 }
9186
9187
9188 //
9189 // ServiceChangeResParm
9190 //
9191
9192 H248_ServiceChangeResParm::H248_ServiceChangeResParm(unsigned tag, PASN_Object::TagClass tagClass)
9193   : PASN_Sequence(tag, tagClass, 5, TRUE, 0)
9194 {
9195   m_serviceChangeVersion.SetConstraints(PASN_Object::FixedConstraint, 0, 99);
9196 }
9197
9198
9199 #ifndef PASN_NOPRINTON
9200 void H248_ServiceChangeResParm::PrintOn(ostream & strm) const
9201 {
9202   int indent = strm.precision() + 2;
9203   strm << "{\n";
9204   if (HasOptionalField(e_serviceChangeMgcId))
9205     strm << setw(indent+21) << "serviceChangeMgcId = " << setprecision(indent) << m_serviceChangeMgcId << '\n';
9206   if (HasOptionalField(e_serviceChangeAddress))
9207     strm << setw(indent+23) << "serviceChangeAddress = " << setprecision(indent) << m_serviceChangeAddress << '\n';
9208   if (HasOptionalField(e_serviceChangeVersion))
9209     strm << setw(indent+23) << "serviceChangeVersion = " << setprecision(indent) << m_serviceChangeVersion << '\n';
9210   if (HasOptionalField(e_serviceChangeProfile))
9211     strm << setw(indent+23) << "serviceChangeProfile = " << setprecision(indent) << m_serviceChangeProfile << '\n';
9212   if (HasOptionalField(e_timestamp))
9213     strm << setw(indent+12) << "timestamp = " << setprecision(indent) << m_timestamp << '\n';
9214   strm << setw(indent-1) << setprecision(indent-2) << "}";
9215 }
9216 #endif
9217
9218
9219 PObject::Comparison H248_ServiceChangeResParm::Compare(const PObject & obj) const
9220 {
9221 #ifndef PASN_LEANANDMEAN
9222   PAssert(PIsDescendant(&obj, H248_ServiceChangeResParm), PInvalidCast);
9223 #endif
9224   const H248_ServiceChangeResParm & other = (const H248_ServiceChangeResParm &)obj;
9225
9226   Comparison result;
9227
9228   if ((result = m_serviceChangeMgcId.Compare(other.m_serviceChangeMgcId)) != EqualTo)
9229     return result;
9230   if ((result = m_serviceChangeAddress.Compare(other.m_serviceChangeAddress)) != EqualTo)
9231     return result;
9232   if ((result = m_serviceChangeVersion.Compare(other.m_serviceChangeVersion)) != EqualTo)
9233     return result;
9234   if ((result = m_serviceChangeProfile.Compare(other.m_serviceChangeProfile)) != EqualTo)
9235     return result;
9236   if ((result = m_timestamp.Compare(other.m_timestamp)) != EqualTo)
9237     return result;
9238
9239   return PASN_Sequence::Compare(other);
9240 }
9241
9242
9243 PINDEX H248_ServiceChangeResParm::GetDataLength() const
9244 {
9245   PINDEX length = 0;
9246   if (HasOptionalField(e_serviceChangeMgcId))
9247     length += m_serviceChangeMgcId.GetObjectLength();
9248   if (HasOptionalField(e_serviceChangeAddress))
9249     length += m_serviceChangeAddress.GetObjectLength();
9250   if (HasOptionalField(e_serviceChangeVersion))
9251     length += m_serviceChangeVersion.GetObjectLength();
9252   if (HasOptionalField(e_serviceChangeProfile))
9253     length += m_serviceChangeProfile.GetObjectLength();
9254   if (HasOptionalField(e_timestamp))
9255     length += m_timestamp.GetObjectLength();
9256   return length;
9257 }
9258
9259
9260 BOOL H248_ServiceChangeResParm::Decode(PASN_Stream & strm)
9261 {
9262   if (!PreambleDecode(strm))
9263     return FALSE;
9264
9265   if (HasOptionalField(e_serviceChangeMgcId) && !m_serviceChangeMgcId.Decode(strm))
9266     return FALSE;
9267   if (HasOptionalField(e_serviceChangeAddress) && !m_serviceChangeAddress.Decode(strm))
9268     return FALSE;
9269   if (HasOptionalField(e_serviceChangeVersion) && !m_serviceChangeVersion.Decode(strm))
9270     return FALSE;
9271   if (HasOptionalField(e_serviceChangeProfile) && !m_serviceChangeProfile.Decode(strm))
9272     return FALSE;
9273   if (HasOptionalField(e_timestamp) && !m_timestamp.Decode(strm))
9274     return FALSE;
9275
9276   return UnknownExtensionsDecode(strm);
9277 }
9278
9279
9280 void H248_ServiceChangeResParm::Encode(PASN_Stream & strm) const
9281 {
9282   PreambleEncode(strm);
9283
9284   if (HasOptionalField(e_serviceChangeMgcId))
9285     m_serviceChangeMgcId.Encode(strm);
9286   if (HasOptionalField(e_serviceChangeAddress))
9287     m_serviceChangeAddress.Encode(strm);
9288   if (HasOptionalField(e_serviceChangeVersion))
9289     m_serviceChangeVersion.Encode(strm);
9290   if (HasOptionalField(e_serviceChangeProfile))
9291     m_serviceChangeProfile.Encode(strm);
9292   if (HasOptionalField(e_timestamp))
9293     m_timestamp.Encode(strm);
9294
9295   UnknownExtensionsEncode(strm);
9296 }
9297
9298
9299 PObject * H248_ServiceChangeResParm::Clone() const
9300 {
9301 #ifndef PASN_LEANANDMEAN
9302   PAssert(IsClass(H248_ServiceChangeResParm::Class()), PInvalidCast);
9303 #endif
9304   return new H248_ServiceChangeResParm(*this);
9305 }
9306
9307
9308 //
9309 // StatisticsParameter
9310 //
9311
9312 H248_StatisticsParameter::H248_StatisticsParameter(unsigned tag, PASN_Object::TagClass tagClass)
9313   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
9314 {
9315 }
9316
9317
9318 #ifndef PASN_NOPRINTON
9319 void H248_StatisticsParameter::PrintOn(ostream & strm) const
9320 {
9321   int indent = strm.precision() + 2;
9322   strm << "{\n";
9323   strm << setw(indent+11) << "statName = " << setprecision(indent) << m_statName << '\n';
9324   if (HasOptionalField(e_statValue))
9325     strm << setw(indent+12) << "statValue = " << setprecision(indent) << m_statValue << '\n';
9326   strm << setw(indent-1) << setprecision(indent-2) << "}";
9327 }
9328 #endif
9329
9330
9331 PObject::Comparison H248_StatisticsParameter::Compare(const PObject & obj) const
9332 {
9333 #ifndef PASN_LEANANDMEAN
9334   PAssert(PIsDescendant(&obj, H248_StatisticsParameter), PInvalidCast);
9335 #endif
9336   const H248_StatisticsParameter & other = (const H248_StatisticsParameter &)obj;
9337
9338   Comparison result;
9339
9340   if ((result = m_statName.Compare(other.m_statName)) != EqualTo)
9341     return result;
9342   if ((result = m_statValue.Compare(other.m_statValue)) != EqualTo)
9343     return result;
9344
9345   return PASN_Sequence::Compare(other);
9346 }
9347
9348
9349 PINDEX H248_StatisticsParameter::GetDataLength() const
9350 {
9351   PINDEX length = 0;
9352   length += m_statName.GetObjectLength();
9353   if (HasOptionalField(e_statValue))
9354     length += m_statValue.GetObjectLength();
9355   return length;
9356 }
9357
9358
9359 BOOL H248_StatisticsParameter::Decode(PASN_Stream & strm)
9360 {
9361   if (!PreambleDecode(strm))
9362     return FALSE;
9363
9364   if (!m_statName.Decode(strm))
9365     return FALSE;
9366   if (HasOptionalField(e_statValue) && !m_statValue.Decode(strm))
9367     return FALSE;
9368
9369   return UnknownExtensionsDecode(strm);
9370 }
9371
9372
9373 void H248_StatisticsParameter::Encode(PASN_Stream & strm) const
9374 {
9375   PreambleEncode(strm);
9376
9377   m_statName.Encode(strm);
9378   if (HasOptionalField(e_statValue))
9379     m_statValue.Encode(strm);
9380
9381   UnknownExtensionsEncode(strm);
9382 }
9383
9384
9385 PObject * H248_StatisticsParameter::Clone() const
9386 {
9387 #ifndef PASN_LEANANDMEAN
9388   PAssert(IsClass(H248_StatisticsParameter::Class()), PInvalidCast);
9389 #endif
9390   return new H248_StatisticsParameter(*this);
9391 }
9392
9393
9394 //
9395 // NonStandardData
9396 //
9397
9398 H248_NonStandardData::H248_NonStandardData(unsigned tag, PASN_Object::TagClass tagClass)
9399   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
9400 {
9401 }
9402
9403
9404 #ifndef PASN_NOPRINTON
9405 void H248_NonStandardData::PrintOn(ostream & strm) const
9406 {
9407   int indent = strm.precision() + 2;
9408   strm << "{\n";
9409   strm << setw(indent+24) << "nonStandardIdentifier = " << setprecision(indent) << m_nonStandardIdentifier << '\n';
9410   strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
9411   strm << setw(indent-1) << setprecision(indent-2) << "}";
9412 }
9413 #endif
9414
9415
9416 PObject::Comparison H248_NonStandardData::Compare(const PObject & obj) const
9417 {
9418 #ifndef PASN_LEANANDMEAN
9419   PAssert(PIsDescendant(&obj, H248_NonStandardData), PInvalidCast);
9420 #endif
9421   const H248_NonStandardData & other = (const H248_NonStandardData &)obj;
9422
9423   Comparison result;
9424
9425   if ((result = m_nonStandardIdentifier.Compare(other.m_nonStandardIdentifier)) != EqualTo)
9426     return result;
9427   if ((result = m_data.Compare(other.m_data)) != EqualTo)
9428     return result;
9429
9430   return PASN_Sequence::Compare(other);
9431 }
9432
9433
9434 PINDEX H248_NonStandardData::GetDataLength() const
9435 {
9436   PINDEX length = 0;
9437   length += m_nonStandardIdentifier.GetObjectLength();
9438   length += m_data.GetObjectLength();
9439   return length;
9440 }
9441
9442
9443 BOOL H248_NonStandardData::Decode(PASN_Stream & strm)
9444 {
9445   if (!PreambleDecode(strm))
9446     return FALSE;
9447
9448   if (!m_nonStandardIdentifier.Decode(strm))
9449     return FALSE;
9450   if (!m_data.Decode(strm))
9451     return FALSE;
9452
9453   return UnknownExtensionsDecode(strm);
9454 }
9455
9456
9457 void H248_NonStandardData::Encode(PASN_Stream & strm) const
9458 {
9459   PreambleEncode(strm);
9460
9461   m_nonStandardIdentifier.Encode(strm);
9462   m_data.Encode(strm);
9463
9464   UnknownExtensionsEncode(strm);
9465 }
9466
9467
9468 PObject * H248_NonStandardData::Clone() const
9469 {
9470 #ifndef PASN_LEANANDMEAN
9471   PAssert(IsClass(H248_NonStandardData::Class()), PInvalidCast);
9472 #endif
9473   return new H248_NonStandardData(*this);
9474 }
9475
9476
9477 //
9478 // MegacoMessage
9479 //
9480
9481 H248_MegacoMessage::H248_MegacoMessage(unsigned tag, PASN_Object::TagClass tagClass)
9482   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
9483 {
9484 }
9485
9486
9487 #ifndef PASN_NOPRINTON
9488 void H248_MegacoMessage::PrintOn(ostream & strm) const
9489 {
9490   int indent = strm.precision() + 2;
9491   strm << "{\n";
9492   if (HasOptionalField(e_authHeader))
9493     strm << setw(indent+13) << "authHeader = " << setprecision(indent) << m_authHeader << '\n';
9494   strm << setw(indent+7) << "mess = " << setprecision(indent) << m_mess << '\n';
9495   strm << setw(indent-1) << setprecision(indent-2) << "}";
9496 }
9497 #endif
9498
9499
9500 PObject::Comparison H248_MegacoMessage::Compare(const PObject & obj) const
9501 {
9502 #ifndef PASN_LEANANDMEAN
9503   PAssert(PIsDescendant(&obj, H248_MegacoMessage), PInvalidCast);
9504 #endif
9505   const H248_MegacoMessage & other = (const H248_MegacoMessage &)obj;
9506
9507   Comparison result;
9508
9509   if ((result = m_authHeader.Compare(other.m_authHeader)) != EqualTo)
9510     return result;
9511   if ((result = m_mess.Compare(other.m_mess)) != EqualTo)
9512     return result;
9513
9514   return PASN_Sequence::Compare(other);
9515 }
9516
9517
9518 PINDEX H248_MegacoMessage::GetDataLength() const
9519 {
9520   PINDEX length = 0;
9521   if (HasOptionalField(e_authHeader))
9522     length += m_authHeader.GetObjectLength();
9523   length += m_mess.GetObjectLength();
9524   return length;
9525 }
9526
9527
9528 BOOL H248_MegacoMessage::Decode(PASN_Stream & strm)
9529 {
9530   if (!PreambleDecode(strm))
9531     return FALSE;
9532
9533   if (HasOptionalField(e_authHeader) && !m_authHeader.Decode(strm))
9534     return FALSE;
9535   if (!m_mess.Decode(strm))
9536     return FALSE;
9537
9538   return UnknownExtensionsDecode(strm);
9539 }
9540
9541
9542 void H248_MegacoMessage::Encode(PASN_Stream & strm) const
9543 {
9544   PreambleEncode(strm);
9545
9546   if (HasOptionalField(e_authHeader))
9547     m_authHeader.Encode(strm);
9548   m_mess.Encode(strm);
9549
9550   UnknownExtensionsEncode(strm);
9551 }
9552
9553
9554 PObject * H248_MegacoMessage::Clone() const
9555 {
9556 #ifndef PASN_LEANANDMEAN
9557   PAssert(IsClass(H248_MegacoMessage::Class()), PInvalidCast);
9558 #endif
9559   return new H248_MegacoMessage(*this);
9560 }
9561
9562
9563 //
9564 // ActionRequest
9565 //
9566
9567 H248_ActionRequest::H248_ActionRequest(unsigned tag, PASN_Object::TagClass tagClass)
9568   : PASN_Sequence(tag, tagClass, 2, FALSE, 0)
9569 {
9570 }
9571
9572
9573 #ifndef PASN_NOPRINTON
9574 void H248_ActionRequest::PrintOn(ostream & strm) const
9575 {
9576   int indent = strm.precision() + 2;
9577   strm << "{\n";
9578   strm << setw(indent+12) << "contextId = " << setprecision(indent) << m_contextId << '\n';
9579   if (HasOptionalField(e_contextRequest))
9580     strm << setw(indent+17) << "contextRequest = " << setprecision(indent) << m_contextRequest << '\n';
9581   if (HasOptionalField(e_contextAttrAuditReq))
9582     strm << setw(indent+22) << "contextAttrAuditReq = " << setprecision(indent) << m_contextAttrAuditReq << '\n';
9583   strm << setw(indent+18) << "commandRequests = " << setprecision(indent) << m_commandRequests << '\n';
9584   strm << setw(indent-1) << setprecision(indent-2) << "}";
9585 }
9586 #endif
9587
9588
9589 PObject::Comparison H248_ActionRequest::Compare(const PObject & obj) const
9590 {
9591 #ifndef PASN_LEANANDMEAN
9592   PAssert(PIsDescendant(&obj, H248_ActionRequest), PInvalidCast);
9593 #endif
9594   const H248_ActionRequest & other = (const H248_ActionRequest &)obj;
9595
9596   Comparison result;
9597
9598   if ((result = m_contextId.Compare(other.m_contextId)) != EqualTo)
9599     return result;
9600   if ((result = m_contextRequest.Compare(other.m_contextRequest)) != EqualTo)
9601     return result;
9602   if ((result = m_contextAttrAuditReq.Compare(other.m_contextAttrAuditReq)) != EqualTo)
9603     return result;
9604   if ((result = m_commandRequests.Compare(other.m_commandRequests)) != EqualTo)
9605     return result;
9606
9607   return PASN_Sequence::Compare(other);
9608 }
9609
9610
9611 PINDEX H248_ActionRequest::GetDataLength() const
9612 {
9613   PINDEX length = 0;
9614   length += m_contextId.GetObjectLength();
9615   if (HasOptionalField(e_contextRequest))
9616     length += m_contextRequest.GetObjectLength();
9617   if (HasOptionalField(e_contextAttrAuditReq))
9618     length += m_contextAttrAuditReq.GetObjectLength();
9619   length += m_commandRequests.GetObjectLength();
9620   return length;
9621 }
9622
9623
9624 BOOL H248_ActionRequest::Decode(PASN_Stream & strm)
9625 {
9626   if (!PreambleDecode(strm))
9627     return FALSE;
9628
9629   if (!m_contextId.Decode(strm))
9630     return FALSE;
9631   if (HasOptionalField(e_contextRequest) && !m_contextRequest.Decode(strm))
9632     return FALSE;
9633   if (HasOptionalField(e_contextAttrAuditReq) && !m_contextAttrAuditReq.Decode(strm))
9634     return FALSE;
9635   if (!m_commandRequests.Decode(strm))
9636     return FALSE;
9637
9638   return UnknownExtensionsDecode(strm);
9639 }
9640
9641
9642 void H248_ActionRequest::Encode(PASN_Stream & strm) const
9643 {
9644   PreambleEncode(strm);
9645
9646   m_contextId.Encode(strm);
9647   if (HasOptionalField(e_contextRequest))
9648     m_contextRequest.Encode(strm);
9649   if (HasOptionalField(e_contextAttrAuditReq))
9650     m_contextAttrAuditReq.Encode(strm);
9651   m_commandRequests.Encode(strm);
9652
9653   UnknownExtensionsEncode(strm);
9654 }
9655
9656
9657 PObject * H248_ActionRequest::Clone() const
9658 {
9659 #ifndef PASN_LEANANDMEAN
9660   PAssert(IsClass(H248_ActionRequest::Class()), PInvalidCast);
9661 #endif
9662   return new H248_ActionRequest(*this);
9663 }
9664
9665
9666 //
9667 // ActionReply
9668 //
9669
9670 H248_ActionReply::H248_ActionReply(unsigned tag, PASN_Object::TagClass tagClass)
9671   : PASN_Sequence(tag, tagClass, 2, FALSE, 0)
9672 {
9673 }
9674
9675
9676 #ifndef PASN_NOPRINTON
9677 void H248_ActionReply::PrintOn(ostream & strm) const
9678 {
9679   int indent = strm.precision() + 2;
9680   strm << "{\n";
9681   strm << setw(indent+12) << "contextId = " << setprecision(indent) << m_contextId << '\n';
9682   if (HasOptionalField(e_errorDescriptor))
9683     strm << setw(indent+18) << "errorDescriptor = " << setprecision(indent) << m_errorDescriptor << '\n';
9684   if (HasOptionalField(e_contextReply))
9685     strm << setw(indent+15) << "contextReply = " << setprecision(indent) << m_contextReply << '\n';
9686   strm << setw(indent+15) << "commandReply = " << setprecision(indent) << m_commandReply << '\n';
9687   strm << setw(indent-1) << setprecision(indent-2) << "}";
9688 }
9689 #endif
9690
9691
9692 PObject::Comparison H248_ActionReply::Compare(const PObject & obj) const
9693 {
9694 #ifndef PASN_LEANANDMEAN
9695   PAssert(PIsDescendant(&obj, H248_ActionReply), PInvalidCast);
9696 #endif
9697   const H248_ActionReply & other = (const H248_ActionReply &)obj;
9698
9699   Comparison result;
9700
9701   if ((result = m_contextId.Compare(other.m_contextId)) != EqualTo)
9702     return result;
9703   if ((result = m_errorDescriptor.Compare(other.m_errorDescriptor)) != EqualTo)
9704     return result;
9705   if ((result = m_contextReply.Compare(other.m_contextReply)) != EqualTo)
9706     return result;
9707   if ((result = m_commandReply.Compare(other.m_commandReply)) != EqualTo)
9708     return result;
9709
9710   return PASN_Sequence::Compare(other);
9711 }
9712
9713
9714 PINDEX H248_ActionReply::GetDataLength() const
9715 {
9716   PINDEX length = 0;
9717   length += m_contextId.GetObjectLength();
9718   if (HasOptionalField(e_errorDescriptor))
9719     length += m_errorDescriptor.GetObjectLength();
9720   if (HasOptionalField(e_contextReply))
9721     length += m_contextReply.GetObjectLength();
9722   length += m_commandReply.GetObjectLength();
9723   return length;
9724 }
9725
9726
9727 BOOL H248_ActionReply::Decode(PASN_Stream & strm)
9728 {
9729   if (!PreambleDecode(strm))
9730     return FALSE;
9731
9732   if (!m_contextId.Decode(strm))
9733     return FALSE;
9734   if (HasOptionalField(e_errorDescriptor) && !m_errorDescriptor.Decode(strm))
9735     return FALSE;
9736   if (HasOptionalField(e_contextReply) && !m_contextReply.Decode(strm))
9737     return FALSE;
9738   if (!m_commandReply.Decode(strm))
9739     return FALSE;
9740
9741   return UnknownExtensionsDecode(strm);
9742 }
9743
9744
9745 void H248_ActionReply::Encode(PASN_Stream & strm) const
9746 {
9747   PreambleEncode(strm);
9748
9749   m_contextId.Encode(strm);
9750   if (HasOptionalField(e_errorDescriptor))
9751     m_errorDescriptor.Encode(strm);
9752   if (HasOptionalField(e_contextReply))
9753     m_contextReply.Encode(strm);
9754   m_commandReply.Encode(strm);
9755
9756   UnknownExtensionsEncode(strm);
9757 }
9758
9759
9760 PObject * H248_ActionReply::Clone() const
9761 {
9762 #ifndef PASN_LEANANDMEAN
9763   PAssert(IsClass(H248_ActionReply::Class()), PInvalidCast);
9764 #endif
9765   return new H248_ActionReply(*this);
9766 }
9767
9768
9769 //
9770 // TopologyRequest
9771 //
9772
9773 H248_TopologyRequest::H248_TopologyRequest(unsigned tag, PASN_Object::TagClass tagClass)
9774   : PASN_Sequence(tag, tagClass, 0, TRUE, 1)
9775 {
9776 }
9777
9778
9779 #ifndef PASN_NOPRINTON
9780 void H248_TopologyRequest::PrintOn(ostream & strm) const
9781 {
9782   int indent = strm.precision() + 2;
9783   strm << "{\n";
9784   strm << setw(indent+18) << "terminationFrom = " << setprecision(indent) << m_terminationFrom << '\n';
9785   strm << setw(indent+16) << "terminationTo = " << setprecision(indent) << m_terminationTo << '\n';
9786   strm << setw(indent+20) << "topologyDirection = " << setprecision(indent) << m_topologyDirection << '\n';
9787   if (HasOptionalField(e_streamID))
9788     strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
9789   strm << setw(indent-1) << setprecision(indent-2) << "}";
9790 }
9791 #endif
9792
9793
9794 PObject::Comparison H248_TopologyRequest::Compare(const PObject & obj) const
9795 {
9796 #ifndef PASN_LEANANDMEAN
9797   PAssert(PIsDescendant(&obj, H248_TopologyRequest), PInvalidCast);
9798 #endif
9799   const H248_TopologyRequest & other = (const H248_TopologyRequest &)obj;
9800
9801   Comparison result;
9802
9803   if ((result = m_terminationFrom.Compare(other.m_terminationFrom)) != EqualTo)
9804     return result;
9805   if ((result = m_terminationTo.Compare(other.m_terminationTo)) != EqualTo)
9806     return result;
9807   if ((result = m_topologyDirection.Compare(other.m_topologyDirection)) != EqualTo)
9808     return result;
9809
9810   return PASN_Sequence::Compare(other);
9811 }
9812
9813
9814 PINDEX H248_TopologyRequest::GetDataLength() const
9815 {
9816   PINDEX length = 0;
9817   length += m_terminationFrom.GetObjectLength();
9818   length += m_terminationTo.GetObjectLength();
9819   length += m_topologyDirection.GetObjectLength();
9820   return length;
9821 }
9822
9823
9824 BOOL H248_TopologyRequest::Decode(PASN_Stream & strm)
9825 {
9826   if (!PreambleDecode(strm))
9827     return FALSE;
9828
9829   if (!m_terminationFrom.Decode(strm))
9830     return FALSE;
9831   if (!m_terminationTo.Decode(strm))
9832     return FALSE;
9833   if (!m_topologyDirection.Decode(strm))
9834     return FALSE;
9835   if (!KnownExtensionDecode(strm, e_streamID, m_streamID))
9836     return FALSE;
9837
9838   return UnknownExtensionsDecode(strm);
9839 }
9840
9841
9842 void H248_TopologyRequest::Encode(PASN_Stream & strm) const
9843 {
9844   PreambleEncode(strm);
9845
9846   m_terminationFrom.Encode(strm);
9847   m_terminationTo.Encode(strm);
9848   m_topologyDirection.Encode(strm);
9849   KnownExtensionEncode(strm, e_streamID, m_streamID);
9850
9851   UnknownExtensionsEncode(strm);
9852 }
9853
9854
9855 PObject * H248_TopologyRequest::Clone() const
9856 {
9857 #ifndef PASN_LEANANDMEAN
9858   PAssert(IsClass(H248_TopologyRequest::Class()), PInvalidCast);
9859 #endif
9860   return new H248_TopologyRequest(*this);
9861 }
9862
9863
9864 //
9865 // SubtractRequest
9866 //
9867
9868 H248_SubtractRequest::H248_SubtractRequest(unsigned tag, PASN_Object::TagClass tagClass)
9869   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
9870 {
9871 }
9872
9873
9874 #ifndef PASN_NOPRINTON
9875 void H248_SubtractRequest::PrintOn(ostream & strm) const
9876 {
9877   int indent = strm.precision() + 2;
9878   strm << "{\n";
9879   strm << setw(indent+16) << "terminationID = " << setprecision(indent) << m_terminationID << '\n';
9880   if (HasOptionalField(e_auditDescriptor))
9881     strm << setw(indent+18) << "auditDescriptor = " << setprecision(indent) << m_auditDescriptor << '\n';
9882   strm << setw(indent-1) << setprecision(indent-2) << "}";
9883 }
9884 #endif
9885
9886
9887 PObject::Comparison H248_SubtractRequest::Compare(const PObject & obj) const
9888 {
9889 #ifndef PASN_LEANANDMEAN
9890   PAssert(PIsDescendant(&obj, H248_SubtractRequest), PInvalidCast);
9891 #endif
9892   const H248_SubtractRequest & other = (const H248_SubtractRequest &)obj;
9893
9894   Comparison result;
9895
9896   if ((result = m_terminationID.Compare(other.m_terminationID)) != EqualTo)
9897     return result;
9898   if ((result = m_auditDescriptor.Compare(other.m_auditDescriptor)) != EqualTo)
9899     return result;
9900
9901   return PASN_Sequence::Compare(other);
9902 }
9903
9904
9905 PINDEX H248_SubtractRequest::GetDataLength() const
9906 {
9907   PINDEX length = 0;
9908   length += m_terminationID.GetObjectLength();
9909   if (HasOptionalField(e_auditDescriptor))
9910     length += m_auditDescriptor.GetObjectLength();
9911   return length;
9912 }
9913
9914
9915 BOOL H248_SubtractRequest::Decode(PASN_Stream & strm)
9916 {
9917   if (!PreambleDecode(strm))
9918     return FALSE;
9919
9920   if (!m_terminationID.Decode(strm))
9921     return FALSE;
9922   if (HasOptionalField(e_auditDescriptor) && !m_auditDescriptor.Decode(strm))
9923     return FALSE;
9924
9925   return UnknownExtensionsDecode(strm);
9926 }
9927
9928
9929 void H248_SubtractRequest::Encode(PASN_Stream & strm) const
9930 {
9931   PreambleEncode(strm);
9932
9933   m_terminationID.Encode(strm);
9934   if (HasOptionalField(e_auditDescriptor))
9935     m_auditDescriptor.Encode(strm);
9936
9937   UnknownExtensionsEncode(strm);
9938 }
9939
9940
9941 PObject * H248_SubtractRequest::Clone() const
9942 {
9943 #ifndef PASN_LEANANDMEAN
9944   PAssert(IsClass(H248_SubtractRequest::Class()), PInvalidCast);
9945 #endif
9946   return new H248_SubtractRequest(*this);
9947 }
9948
9949
9950 //
9951 // AuditRequest
9952 //
9953
9954 H248_AuditRequest::H248_AuditRequest(unsigned tag, PASN_Object::TagClass tagClass)
9955   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
9956 {
9957 }
9958
9959
9960 #ifndef PASN_NOPRINTON
9961 void H248_AuditRequest::PrintOn(ostream & strm) const
9962 {
9963   int indent = strm.precision() + 2;
9964   strm << "{\n";
9965   strm << setw(indent+16) << "terminationID = " << setprecision(indent) << m_terminationID << '\n';
9966   strm << setw(indent+18) << "auditDescriptor = " << setprecision(indent) << m_auditDescriptor << '\n';
9967   strm << setw(indent-1) << setprecision(indent-2) << "}";
9968 }
9969 #endif
9970
9971
9972 PObject::Comparison H248_AuditRequest::Compare(const PObject & obj) const
9973 {
9974 #ifndef PASN_LEANANDMEAN
9975   PAssert(PIsDescendant(&obj, H248_AuditRequest), PInvalidCast);
9976 #endif
9977   const H248_AuditRequest & other = (const H248_AuditRequest &)obj;
9978
9979   Comparison result;
9980
9981   if ((result = m_terminationID.Compare(other.m_terminationID)) != EqualTo)
9982     return result;
9983   if ((result = m_auditDescriptor.Compare(other.m_auditDescriptor)) != EqualTo)
9984     return result;
9985
9986   return PASN_Sequence::Compare(other);
9987 }
9988
9989
9990 PINDEX H248_AuditRequest::GetDataLength() const
9991 {
9992   PINDEX length = 0;
9993   length += m_terminationID.GetObjectLength();
9994   length += m_auditDescriptor.GetObjectLength();
9995   return length;
9996 }
9997
9998
9999 BOOL H248_AuditRequest::Decode(PASN_Stream & strm)
10000 {
10001   if (!PreambleDecode(strm))
10002     return FALSE;
10003
10004   if (!m_terminationID.Decode(strm))
10005     return FALSE;
10006   if (!m_auditDescriptor.Decode(strm))
10007     return FALSE;
10008
10009   return UnknownExtensionsDecode(strm);
10010 }
10011
10012
10013 void H248_AuditRequest::Encode(PASN_Stream & strm) const
10014 {
10015   PreambleEncode(strm);
10016
10017   m_terminationID.Encode(strm);
10018   m_auditDescriptor.Encode(strm);
10019
10020   UnknownExtensionsEncode(strm);
10021 }
10022
10023
10024 PObject * H248_AuditRequest::Clone() const
10025 {
10026 #ifndef PASN_LEANANDMEAN
10027   PAssert(IsClass(H248_AuditRequest::Class()), PInvalidCast);
10028 #endif
10029   return new H248_AuditRequest(*this);
10030 }
10031
10032
10033 //
10034 // AuditResult
10035 //
10036
10037 H248_AuditResult::H248_AuditResult(unsigned tag, PASN_Object::TagClass tagClass)
10038   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
10039 {
10040 }
10041
10042
10043 #ifndef PASN_NOPRINTON
10044 void H248_AuditResult::PrintOn(ostream & strm) const
10045 {
10046   int indent = strm.precision() + 2;
10047   strm << "{\n";
10048   strm << setw(indent+16) << "terminationID = " << setprecision(indent) << m_terminationID << '\n';
10049   strm << setw(indent+25) << "terminationAuditResult = " << setprecision(indent) << m_terminationAuditResult << '\n';
10050   strm << setw(indent-1) << setprecision(indent-2) << "}";
10051 }
10052 #endif
10053
10054
10055 PObject::Comparison H248_AuditResult::Compare(const PObject & obj) const
10056 {
10057 #ifndef PASN_LEANANDMEAN
10058   PAssert(PIsDescendant(&obj, H248_AuditResult), PInvalidCast);
10059 #endif
10060   const H248_AuditResult & other = (const H248_AuditResult &)obj;
10061
10062   Comparison result;
10063
10064   if ((result = m_terminationID.Compare(other.m_terminationID)) != EqualTo)
10065     return result;
10066   if ((result = m_terminationAuditResult.Compare(other.m_terminationAuditResult)) != EqualTo)
10067     return result;
10068
10069   return PASN_Sequence::Compare(other);
10070 }
10071
10072
10073 PINDEX H248_AuditResult::GetDataLength() const
10074 {
10075   PINDEX length = 0;
10076   length += m_terminationID.GetObjectLength();
10077   length += m_terminationAuditResult.GetObjectLength();
10078   return length;
10079 }
10080
10081
10082 BOOL H248_AuditResult::Decode(PASN_Stream & strm)
10083 {
10084   if (!PreambleDecode(strm))
10085     return FALSE;
10086
10087   if (!m_terminationID.Decode(strm))
10088     return FALSE;
10089   if (!m_terminationAuditResult.Decode(strm))
10090     return FALSE;
10091
10092   return UnknownExtensionsDecode(strm);
10093 }
10094
10095
10096 void H248_AuditResult::Encode(PASN_Stream & strm) const
10097 {
10098   PreambleEncode(strm);
10099
10100   m_terminationID.Encode(strm);
10101   m_terminationAuditResult.Encode(strm);
10102
10103   UnknownExtensionsEncode(strm);
10104 }
10105
10106
10107 PObject * H248_AuditResult::Clone() const
10108 {
10109 #ifndef PASN_LEANANDMEAN
10110   PAssert(IsClass(H248_AuditResult::Class()), PInvalidCast);
10111 #endif
10112   return new H248_AuditResult(*this);
10113 }
10114
10115
10116 //
10117 // IndAudMediaDescriptor
10118 //
10119
10120 H248_IndAudMediaDescriptor::H248_IndAudMediaDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
10121   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
10122 {
10123 }
10124
10125
10126 #ifndef PASN_NOPRINTON
10127 void H248_IndAudMediaDescriptor::PrintOn(ostream & strm) const
10128 {
10129   int indent = strm.precision() + 2;
10130   strm << "{\n";
10131   if (HasOptionalField(e_termStateDescr))
10132     strm << setw(indent+17) << "termStateDescr = " << setprecision(indent) << m_termStateDescr << '\n';
10133   if (HasOptionalField(e_streams))
10134     strm << setw(indent+10) << "streams = " << setprecision(indent) << m_streams << '\n';
10135   strm << setw(indent-1) << setprecision(indent-2) << "}";
10136 }
10137 #endif
10138
10139
10140 PObject::Comparison H248_IndAudMediaDescriptor::Compare(const PObject & obj) const
10141 {
10142 #ifndef PASN_LEANANDMEAN
10143   PAssert(PIsDescendant(&obj, H248_IndAudMediaDescriptor), PInvalidCast);
10144 #endif
10145   const H248_IndAudMediaDescriptor & other = (const H248_IndAudMediaDescriptor &)obj;
10146
10147   Comparison result;
10148
10149   if ((result = m_termStateDescr.Compare(other.m_termStateDescr)) != EqualTo)
10150     return result;
10151   if ((result = m_streams.Compare(other.m_streams)) != EqualTo)
10152     return result;
10153
10154   return PASN_Sequence::Compare(other);
10155 }
10156
10157
10158 PINDEX H248_IndAudMediaDescriptor::GetDataLength() const
10159 {
10160   PINDEX length = 0;
10161   if (HasOptionalField(e_termStateDescr))
10162     length += m_termStateDescr.GetObjectLength();
10163   if (HasOptionalField(e_streams))
10164     length += m_streams.GetObjectLength();
10165   return length;
10166 }
10167
10168
10169 BOOL H248_IndAudMediaDescriptor::Decode(PASN_Stream & strm)
10170 {
10171   if (!PreambleDecode(strm))
10172     return FALSE;
10173
10174   if (HasOptionalField(e_termStateDescr) && !m_termStateDescr.Decode(strm))
10175     return FALSE;
10176   if (HasOptionalField(e_streams) && !m_streams.Decode(strm))
10177     return FALSE;
10178
10179   return UnknownExtensionsDecode(strm);
10180 }
10181
10182
10183 void H248_IndAudMediaDescriptor::Encode(PASN_Stream & strm) const
10184 {
10185   PreambleEncode(strm);
10186
10187   if (HasOptionalField(e_termStateDescr))
10188     m_termStateDescr.Encode(strm);
10189   if (HasOptionalField(e_streams))
10190     m_streams.Encode(strm);
10191
10192   UnknownExtensionsEncode(strm);
10193 }
10194
10195
10196 PObject * H248_IndAudMediaDescriptor::Clone() const
10197 {
10198 #ifndef PASN_LEANANDMEAN
10199   PAssert(IsClass(H248_IndAudMediaDescriptor::Class()), PInvalidCast);
10200 #endif
10201   return new H248_IndAudMediaDescriptor(*this);
10202 }
10203
10204
10205 //
10206 // IndAudStreamParms
10207 //
10208
10209 H248_IndAudStreamParms::H248_IndAudStreamParms(unsigned tag, PASN_Object::TagClass tagClass)
10210   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
10211 {
10212 }
10213
10214
10215 #ifndef PASN_NOPRINTON
10216 void H248_IndAudStreamParms::PrintOn(ostream & strm) const
10217 {
10218   int indent = strm.precision() + 2;
10219   strm << "{\n";
10220   if (HasOptionalField(e_localControlDescriptor))
10221     strm << setw(indent+25) << "localControlDescriptor = " << setprecision(indent) << m_localControlDescriptor << '\n';
10222   if (HasOptionalField(e_localDescriptor))
10223     strm << setw(indent+18) << "localDescriptor = " << setprecision(indent) << m_localDescriptor << '\n';
10224   if (HasOptionalField(e_remoteDescriptor))
10225     strm << setw(indent+19) << "remoteDescriptor = " << setprecision(indent) << m_remoteDescriptor << '\n';
10226   strm << setw(indent-1) << setprecision(indent-2) << "}";
10227 }
10228 #endif
10229
10230
10231 PObject::Comparison H248_IndAudStreamParms::Compare(const PObject & obj) const
10232 {
10233 #ifndef PASN_LEANANDMEAN
10234   PAssert(PIsDescendant(&obj, H248_IndAudStreamParms), PInvalidCast);
10235 #endif
10236   const H248_IndAudStreamParms & other = (const H248_IndAudStreamParms &)obj;
10237
10238   Comparison result;
10239
10240   if ((result = m_localControlDescriptor.Compare(other.m_localControlDescriptor)) != EqualTo)
10241     return result;
10242   if ((result = m_localDescriptor.Compare(other.m_localDescriptor)) != EqualTo)
10243     return result;
10244   if ((result = m_remoteDescriptor.Compare(other.m_remoteDescriptor)) != EqualTo)
10245     return result;
10246
10247   return PASN_Sequence::Compare(other);
10248 }
10249
10250
10251 PINDEX H248_IndAudStreamParms::GetDataLength() const
10252 {
10253   PINDEX length = 0;
10254   if (HasOptionalField(e_localControlDescriptor))
10255     length += m_localControlDescriptor.GetObjectLength();
10256   if (HasOptionalField(e_localDescriptor))
10257     length += m_localDescriptor.GetObjectLength();
10258   if (HasOptionalField(e_remoteDescriptor))
10259     length += m_remoteDescriptor.GetObjectLength();
10260   return length;
10261 }
10262
10263
10264 BOOL H248_IndAudStreamParms::Decode(PASN_Stream & strm)
10265 {
10266   if (!PreambleDecode(strm))
10267     return FALSE;
10268
10269   if (HasOptionalField(e_localControlDescriptor) && !m_localControlDescriptor.Decode(strm))
10270     return FALSE;
10271   if (HasOptionalField(e_localDescriptor) && !m_localDescriptor.Decode(strm))
10272     return FALSE;
10273   if (HasOptionalField(e_remoteDescriptor) && !m_remoteDescriptor.Decode(strm))
10274     return FALSE;
10275
10276   return UnknownExtensionsDecode(strm);
10277 }
10278
10279
10280 void H248_IndAudStreamParms::Encode(PASN_Stream & strm) const
10281 {
10282   PreambleEncode(strm);
10283
10284   if (HasOptionalField(e_localControlDescriptor))
10285     m_localControlDescriptor.Encode(strm);
10286   if (HasOptionalField(e_localDescriptor))
10287     m_localDescriptor.Encode(strm);
10288   if (HasOptionalField(e_remoteDescriptor))
10289     m_remoteDescriptor.Encode(strm);
10290
10291   UnknownExtensionsEncode(strm);
10292 }
10293
10294
10295 PObject * H248_IndAudStreamParms::Clone() const
10296 {
10297 #ifndef PASN_LEANANDMEAN
10298   PAssert(IsClass(H248_IndAudStreamParms::Class()), PInvalidCast);
10299 #endif
10300   return new H248_IndAudStreamParms(*this);
10301 }
10302
10303
10304 //
10305 // IndAudSeqSigList
10306 //
10307
10308 H248_IndAudSeqSigList::H248_IndAudSeqSigList(unsigned tag, PASN_Object::TagClass tagClass)
10309   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
10310 {
10311   m_id.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
10312 }
10313
10314
10315 #ifndef PASN_NOPRINTON
10316 void H248_IndAudSeqSigList::PrintOn(ostream & strm) const
10317 {
10318   int indent = strm.precision() + 2;
10319   strm << "{\n";
10320   strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
10321   if (HasOptionalField(e_signalList))
10322     strm << setw(indent+13) << "signalList = " << setprecision(indent) << m_signalList << '\n';
10323   strm << setw(indent-1) << setprecision(indent-2) << "}";
10324 }
10325 #endif
10326
10327
10328 PObject::Comparison H248_IndAudSeqSigList::Compare(const PObject & obj) const
10329 {
10330 #ifndef PASN_LEANANDMEAN
10331   PAssert(PIsDescendant(&obj, H248_IndAudSeqSigList), PInvalidCast);
10332 #endif
10333   const H248_IndAudSeqSigList & other = (const H248_IndAudSeqSigList &)obj;
10334
10335   Comparison result;
10336
10337   if ((result = m_id.Compare(other.m_id)) != EqualTo)
10338     return result;
10339   if ((result = m_signalList.Compare(other.m_signalList)) != EqualTo)
10340     return result;
10341
10342   return PASN_Sequence::Compare(other);
10343 }
10344
10345
10346 PINDEX H248_IndAudSeqSigList::GetDataLength() const
10347 {
10348   PINDEX length = 0;
10349   length += m_id.GetObjectLength();
10350   if (HasOptionalField(e_signalList))
10351     length += m_signalList.GetObjectLength();
10352   return length;
10353 }
10354
10355
10356 BOOL H248_IndAudSeqSigList::Decode(PASN_Stream & strm)
10357 {
10358   if (!PreambleDecode(strm))
10359     return FALSE;
10360
10361   if (!m_id.Decode(strm))
10362     return FALSE;
10363   if (HasOptionalField(e_signalList) && !m_signalList.Decode(strm))
10364     return FALSE;
10365
10366   return UnknownExtensionsDecode(strm);
10367 }
10368
10369
10370 void H248_IndAudSeqSigList::Encode(PASN_Stream & strm) const
10371 {
10372   PreambleEncode(strm);
10373
10374   m_id.Encode(strm);
10375   if (HasOptionalField(e_signalList))
10376     m_signalList.Encode(strm);
10377
10378   UnknownExtensionsEncode(strm);
10379 }
10380
10381
10382 PObject * H248_IndAudSeqSigList::Clone() const
10383 {
10384 #ifndef PASN_LEANANDMEAN
10385   PAssert(IsClass(H248_IndAudSeqSigList::Class()), PInvalidCast);
10386 #endif
10387   return new H248_IndAudSeqSigList(*this);
10388 }
10389
10390
10391 //
10392 // NotifyRequest
10393 //
10394
10395 H248_NotifyRequest::H248_NotifyRequest(unsigned tag, PASN_Object::TagClass tagClass)
10396   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
10397 {
10398 }
10399
10400
10401 #ifndef PASN_NOPRINTON
10402 void H248_NotifyRequest::PrintOn(ostream & strm) const
10403 {
10404   int indent = strm.precision() + 2;
10405   strm << "{\n";
10406   strm << setw(indent+16) << "terminationID = " << setprecision(indent) << m_terminationID << '\n';
10407   strm << setw(indent+27) << "observedEventsDescriptor = " << setprecision(indent) << m_observedEventsDescriptor << '\n';
10408   if (HasOptionalField(e_errorDescriptor))
10409     strm << setw(indent+18) << "errorDescriptor = " << setprecision(indent) << m_errorDescriptor << '\n';
10410   strm << setw(indent-1) << setprecision(indent-2) << "}";
10411 }
10412 #endif
10413
10414
10415 PObject::Comparison H248_NotifyRequest::Compare(const PObject & obj) const
10416 {
10417 #ifndef PASN_LEANANDMEAN
10418   PAssert(PIsDescendant(&obj, H248_NotifyRequest), PInvalidCast);
10419 #endif
10420   const H248_NotifyRequest & other = (const H248_NotifyRequest &)obj;
10421
10422   Comparison result;
10423
10424   if ((result = m_terminationID.Compare(other.m_terminationID)) != EqualTo)
10425     return result;
10426   if ((result = m_observedEventsDescriptor.Compare(other.m_observedEventsDescriptor)) != EqualTo)
10427     return result;
10428   if ((result = m_errorDescriptor.Compare(other.m_errorDescriptor)) != EqualTo)
10429     return result;
10430
10431   return PASN_Sequence::Compare(other);
10432 }
10433
10434
10435 PINDEX H248_NotifyRequest::GetDataLength() const
10436 {
10437   PINDEX length = 0;
10438   length += m_terminationID.GetObjectLength();
10439   length += m_observedEventsDescriptor.GetObjectLength();
10440   if (HasOptionalField(e_errorDescriptor))
10441     length += m_errorDescriptor.GetObjectLength();
10442   return length;
10443 }
10444
10445
10446 BOOL H248_NotifyRequest::Decode(PASN_Stream & strm)
10447 {
10448   if (!PreambleDecode(strm))
10449     return FALSE;
10450
10451   if (!m_terminationID.Decode(strm))
10452     return FALSE;
10453   if (!m_observedEventsDescriptor.Decode(strm))
10454     return FALSE;
10455   if (HasOptionalField(e_errorDescriptor) && !m_errorDescriptor.Decode(strm))
10456     return FALSE;
10457
10458   return UnknownExtensionsDecode(strm);
10459 }
10460
10461
10462 void H248_NotifyRequest::Encode(PASN_Stream & strm) const
10463 {
10464   PreambleEncode(strm);
10465
10466   m_terminationID.Encode(strm);
10467   m_observedEventsDescriptor.Encode(strm);
10468   if (HasOptionalField(e_errorDescriptor))
10469     m_errorDescriptor.Encode(strm);
10470
10471   UnknownExtensionsEncode(strm);
10472 }
10473
10474
10475 PObject * H248_NotifyRequest::Clone() const
10476 {
10477 #ifndef PASN_LEANANDMEAN
10478   PAssert(IsClass(H248_NotifyRequest::Class()), PInvalidCast);
10479 #endif
10480   return new H248_NotifyRequest(*this);
10481 }
10482
10483
10484 //
10485 // ObservedEvent
10486 //
10487
10488 H248_ObservedEvent::H248_ObservedEvent(unsigned tag, PASN_Object::TagClass tagClass)
10489   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
10490 {
10491 }
10492
10493
10494 #ifndef PASN_NOPRINTON
10495 void H248_ObservedEvent::PrintOn(ostream & strm) const
10496 {
10497   int indent = strm.precision() + 2;
10498   strm << "{\n";
10499   strm << setw(indent+12) << "eventName = " << setprecision(indent) << m_eventName << '\n';
10500   if (HasOptionalField(e_streamID))
10501     strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
10502   strm << setw(indent+15) << "eventParList = " << setprecision(indent) << m_eventParList << '\n';
10503   if (HasOptionalField(e_timeNotation))
10504     strm << setw(indent+15) << "timeNotation = " << setprecision(indent) << m_timeNotation << '\n';
10505   strm << setw(indent-1) << setprecision(indent-2) << "}";
10506 }
10507 #endif
10508
10509
10510 PObject::Comparison H248_ObservedEvent::Compare(const PObject & obj) const
10511 {
10512 #ifndef PASN_LEANANDMEAN
10513   PAssert(PIsDescendant(&obj, H248_ObservedEvent), PInvalidCast);
10514 #endif
10515   const H248_ObservedEvent & other = (const H248_ObservedEvent &)obj;
10516
10517   Comparison result;
10518
10519   if ((result = m_eventName.Compare(other.m_eventName)) != EqualTo)
10520     return result;
10521   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
10522     return result;
10523   if ((result = m_eventParList.Compare(other.m_eventParList)) != EqualTo)
10524     return result;
10525   if ((result = m_timeNotation.Compare(other.m_timeNotation)) != EqualTo)
10526     return result;
10527
10528   return PASN_Sequence::Compare(other);
10529 }
10530
10531
10532 PINDEX H248_ObservedEvent::GetDataLength() const
10533 {
10534   PINDEX length = 0;
10535   length += m_eventName.GetObjectLength();
10536   if (HasOptionalField(e_streamID))
10537     length += m_streamID.GetObjectLength();
10538   length += m_eventParList.GetObjectLength();
10539   if (HasOptionalField(e_timeNotation))
10540     length += m_timeNotation.GetObjectLength();
10541   return length;
10542 }
10543
10544
10545 BOOL H248_ObservedEvent::Decode(PASN_Stream & strm)
10546 {
10547   if (!PreambleDecode(strm))
10548     return FALSE;
10549
10550   if (!m_eventName.Decode(strm))
10551     return FALSE;
10552   if (HasOptionalField(e_streamID) && !m_streamID.Decode(strm))
10553     return FALSE;
10554   if (!m_eventParList.Decode(strm))
10555     return FALSE;
10556   if (HasOptionalField(e_timeNotation) && !m_timeNotation.Decode(strm))
10557     return FALSE;
10558
10559   return UnknownExtensionsDecode(strm);
10560 }
10561
10562
10563 void H248_ObservedEvent::Encode(PASN_Stream & strm) const
10564 {
10565   PreambleEncode(strm);
10566
10567   m_eventName.Encode(strm);
10568   if (HasOptionalField(e_streamID))
10569     m_streamID.Encode(strm);
10570   m_eventParList.Encode(strm);
10571   if (HasOptionalField(e_timeNotation))
10572     m_timeNotation.Encode(strm);
10573
10574   UnknownExtensionsEncode(strm);
10575 }
10576
10577
10578 PObject * H248_ObservedEvent::Clone() const
10579 {
10580 #ifndef PASN_LEANANDMEAN
10581   PAssert(IsClass(H248_ObservedEvent::Class()), PInvalidCast);
10582 #endif
10583   return new H248_ObservedEvent(*this);
10584 }
10585
10586
10587 //
10588 // MediaDescriptor
10589 //
10590
10591 H248_MediaDescriptor::H248_MediaDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
10592   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
10593 {
10594 }
10595
10596
10597 #ifndef PASN_NOPRINTON
10598 void H248_MediaDescriptor::PrintOn(ostream & strm) const
10599 {
10600   int indent = strm.precision() + 2;
10601   strm << "{\n";
10602   if (HasOptionalField(e_termStateDescr))
10603     strm << setw(indent+17) << "termStateDescr = " << setprecision(indent) << m_termStateDescr << '\n';
10604   if (HasOptionalField(e_streams))
10605     strm << setw(indent+10) << "streams = " << setprecision(indent) << m_streams << '\n';
10606   strm << setw(indent-1) << setprecision(indent-2) << "}";
10607 }
10608 #endif
10609
10610
10611 PObject::Comparison H248_MediaDescriptor::Compare(const PObject & obj) const
10612 {
10613 #ifndef PASN_LEANANDMEAN
10614   PAssert(PIsDescendant(&obj, H248_MediaDescriptor), PInvalidCast);
10615 #endif
10616   const H248_MediaDescriptor & other = (const H248_MediaDescriptor &)obj;
10617
10618   Comparison result;
10619
10620   if ((result = m_termStateDescr.Compare(other.m_termStateDescr)) != EqualTo)
10621     return result;
10622   if ((result = m_streams.Compare(other.m_streams)) != EqualTo)
10623     return result;
10624
10625   return PASN_Sequence::Compare(other);
10626 }
10627
10628
10629 PINDEX H248_MediaDescriptor::GetDataLength() const
10630 {
10631   PINDEX length = 0;
10632   if (HasOptionalField(e_termStateDescr))
10633     length += m_termStateDescr.GetObjectLength();
10634   if (HasOptionalField(e_streams))
10635     length += m_streams.GetObjectLength();
10636   return length;
10637 }
10638
10639
10640 BOOL H248_MediaDescriptor::Decode(PASN_Stream & strm)
10641 {
10642   if (!PreambleDecode(strm))
10643     return FALSE;
10644
10645   if (HasOptionalField(e_termStateDescr) && !m_termStateDescr.Decode(strm))
10646     return FALSE;
10647   if (HasOptionalField(e_streams) && !m_streams.Decode(strm))
10648     return FALSE;
10649
10650   return UnknownExtensionsDecode(strm);
10651 }
10652
10653
10654 void H248_MediaDescriptor::Encode(PASN_Stream & strm) const
10655 {
10656   PreambleEncode(strm);
10657
10658   if (HasOptionalField(e_termStateDescr))
10659     m_termStateDescr.Encode(strm);
10660   if (HasOptionalField(e_streams))
10661     m_streams.Encode(strm);
10662
10663   UnknownExtensionsEncode(strm);
10664 }
10665
10666
10667 PObject * H248_MediaDescriptor::Clone() const
10668 {
10669 #ifndef PASN_LEANANDMEAN
10670   PAssert(IsClass(H248_MediaDescriptor::Class()), PInvalidCast);
10671 #endif
10672   return new H248_MediaDescriptor(*this);
10673 }
10674
10675
10676 //
10677 // StreamParms
10678 //
10679
10680 H248_StreamParms::H248_StreamParms(unsigned tag, PASN_Object::TagClass tagClass)
10681   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
10682 {
10683 }
10684
10685
10686 #ifndef PASN_NOPRINTON
10687 void H248_StreamParms::PrintOn(ostream & strm) const
10688 {
10689   int indent = strm.precision() + 2;
10690   strm << "{\n";
10691   if (HasOptionalField(e_localControlDescriptor))
10692     strm << setw(indent+25) << "localControlDescriptor = " << setprecision(indent) << m_localControlDescriptor << '\n';
10693   if (HasOptionalField(e_localDescriptor))
10694     strm << setw(indent+18) << "localDescriptor = " << setprecision(indent) << m_localDescriptor << '\n';
10695   if (HasOptionalField(e_remoteDescriptor))
10696     strm << setw(indent+19) << "remoteDescriptor = " << setprecision(indent) << m_remoteDescriptor << '\n';
10697   strm << setw(indent-1) << setprecision(indent-2) << "}";
10698 }
10699 #endif
10700
10701
10702 PObject::Comparison H248_StreamParms::Compare(const PObject & obj) const
10703 {
10704 #ifndef PASN_LEANANDMEAN
10705   PAssert(PIsDescendant(&obj, H248_StreamParms), PInvalidCast);
10706 #endif
10707   const H248_StreamParms & other = (const H248_StreamParms &)obj;
10708
10709   Comparison result;
10710
10711   if ((result = m_localControlDescriptor.Compare(other.m_localControlDescriptor)) != EqualTo)
10712     return result;
10713   if ((result = m_localDescriptor.Compare(other.m_localDescriptor)) != EqualTo)
10714     return result;
10715   if ((result = m_remoteDescriptor.Compare(other.m_remoteDescriptor)) != EqualTo)
10716     return result;
10717
10718   return PASN_Sequence::Compare(other);
10719 }
10720
10721
10722 PINDEX H248_StreamParms::GetDataLength() const
10723 {
10724   PINDEX length = 0;
10725   if (HasOptionalField(e_localControlDescriptor))
10726     length += m_localControlDescriptor.GetObjectLength();
10727   if (HasOptionalField(e_localDescriptor))
10728     length += m_localDescriptor.GetObjectLength();
10729   if (HasOptionalField(e_remoteDescriptor))
10730     length += m_remoteDescriptor.GetObjectLength();
10731   return length;
10732 }
10733
10734
10735 BOOL H248_StreamParms::Decode(PASN_Stream & strm)
10736 {
10737   if (!PreambleDecode(strm))
10738     return FALSE;
10739
10740   if (HasOptionalField(e_localControlDescriptor) && !m_localControlDescriptor.Decode(strm))
10741     return FALSE;
10742   if (HasOptionalField(e_localDescriptor) && !m_localDescriptor.Decode(strm))
10743     return FALSE;
10744   if (HasOptionalField(e_remoteDescriptor) && !m_remoteDescriptor.Decode(strm))
10745     return FALSE;
10746
10747   return UnknownExtensionsDecode(strm);
10748 }
10749
10750
10751 void H248_StreamParms::Encode(PASN_Stream & strm) const
10752 {
10753   PreambleEncode(strm);
10754
10755   if (HasOptionalField(e_localControlDescriptor))
10756     m_localControlDescriptor.Encode(strm);
10757   if (HasOptionalField(e_localDescriptor))
10758     m_localDescriptor.Encode(strm);
10759   if (HasOptionalField(e_remoteDescriptor))
10760     m_remoteDescriptor.Encode(strm);
10761
10762   UnknownExtensionsEncode(strm);
10763 }
10764
10765
10766 PObject * H248_StreamParms::Clone() const
10767 {
10768 #ifndef PASN_LEANANDMEAN
10769   PAssert(IsClass(H248_StreamParms::Class()), PInvalidCast);
10770 #endif
10771   return new H248_StreamParms(*this);
10772 }
10773
10774
10775 //
10776 // MuxDescriptor
10777 //
10778
10779 H248_MuxDescriptor::H248_MuxDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
10780   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
10781 {
10782 }
10783
10784
10785 #ifndef PASN_NOPRINTON
10786 void H248_MuxDescriptor::PrintOn(ostream & strm) const
10787 {
10788   int indent = strm.precision() + 2;
10789   strm << "{\n";
10790   strm << setw(indent+10) << "muxType = " << setprecision(indent) << m_muxType << '\n';
10791   strm << setw(indent+11) << "termList = " << setprecision(indent) << m_termList << '\n';
10792   if (HasOptionalField(e_nonStandardData))
10793     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
10794   strm << setw(indent-1) << setprecision(indent-2) << "}";
10795 }
10796 #endif
10797
10798
10799 PObject::Comparison H248_MuxDescriptor::Compare(const PObject & obj) const
10800 {
10801 #ifndef PASN_LEANANDMEAN
10802   PAssert(PIsDescendant(&obj, H248_MuxDescriptor), PInvalidCast);
10803 #endif
10804   const H248_MuxDescriptor & other = (const H248_MuxDescriptor &)obj;
10805
10806   Comparison result;
10807
10808   if ((result = m_muxType.Compare(other.m_muxType)) != EqualTo)
10809     return result;
10810   if ((result = m_termList.Compare(other.m_termList)) != EqualTo)
10811     return result;
10812   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
10813     return result;
10814
10815   return PASN_Sequence::Compare(other);
10816 }
10817
10818
10819 PINDEX H248_MuxDescriptor::GetDataLength() const
10820 {
10821   PINDEX length = 0;
10822   length += m_muxType.GetObjectLength();
10823   length += m_termList.GetObjectLength();
10824   if (HasOptionalField(e_nonStandardData))
10825     length += m_nonStandardData.GetObjectLength();
10826   return length;
10827 }
10828
10829
10830 BOOL H248_MuxDescriptor::Decode(PASN_Stream & strm)
10831 {
10832   if (!PreambleDecode(strm))
10833     return FALSE;
10834
10835   if (!m_muxType.Decode(strm))
10836     return FALSE;
10837   if (!m_termList.Decode(strm))
10838     return FALSE;
10839   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
10840     return FALSE;
10841
10842   return UnknownExtensionsDecode(strm);
10843 }
10844
10845
10846 void H248_MuxDescriptor::Encode(PASN_Stream & strm) const
10847 {
10848   PreambleEncode(strm);
10849
10850   m_muxType.Encode(strm);
10851   m_termList.Encode(strm);
10852   if (HasOptionalField(e_nonStandardData))
10853     m_nonStandardData.Encode(strm);
10854
10855   UnknownExtensionsEncode(strm);
10856 }
10857
10858
10859 PObject * H248_MuxDescriptor::Clone() const
10860 {
10861 #ifndef PASN_LEANANDMEAN
10862   PAssert(IsClass(H248_MuxDescriptor::Class()), PInvalidCast);
10863 #endif
10864   return new H248_MuxDescriptor(*this);
10865 }
10866
10867
10868 //
10869 // RequestedActions
10870 //
10871
10872 H248_RequestedActions::H248_RequestedActions(unsigned tag, PASN_Object::TagClass tagClass)
10873   : PASN_Sequence(tag, tagClass, 4, TRUE, 0)
10874 {
10875 }
10876
10877
10878 #ifndef PASN_NOPRINTON
10879 void H248_RequestedActions::PrintOn(ostream & strm) const
10880 {
10881   int indent = strm.precision() + 2;
10882   strm << "{\n";
10883   if (HasOptionalField(e_keepActive))
10884     strm << setw(indent+13) << "keepActive = " << setprecision(indent) << m_keepActive << '\n';
10885   if (HasOptionalField(e_eventDM))
10886     strm << setw(indent+10) << "eventDM = " << setprecision(indent) << m_eventDM << '\n';
10887   if (HasOptionalField(e_secondEvent))
10888     strm << setw(indent+14) << "secondEvent = " << setprecision(indent) << m_secondEvent << '\n';
10889   if (HasOptionalField(e_signalsDescriptor))
10890     strm << setw(indent+20) << "signalsDescriptor = " << setprecision(indent) << m_signalsDescriptor << '\n';
10891   strm << setw(indent-1) << setprecision(indent-2) << "}";
10892 }
10893 #endif
10894
10895
10896 PObject::Comparison H248_RequestedActions::Compare(const PObject & obj) const
10897 {
10898 #ifndef PASN_LEANANDMEAN
10899   PAssert(PIsDescendant(&obj, H248_RequestedActions), PInvalidCast);
10900 #endif
10901   const H248_RequestedActions & other = (const H248_RequestedActions &)obj;
10902
10903   Comparison result;
10904
10905   if ((result = m_keepActive.Compare(other.m_keepActive)) != EqualTo)
10906     return result;
10907   if ((result = m_eventDM.Compare(other.m_eventDM)) != EqualTo)
10908     return result;
10909   if ((result = m_secondEvent.Compare(other.m_secondEvent)) != EqualTo)
10910     return result;
10911   if ((result = m_signalsDescriptor.Compare(other.m_signalsDescriptor)) != EqualTo)
10912     return result;
10913
10914   return PASN_Sequence::Compare(other);
10915 }
10916
10917
10918 PINDEX H248_RequestedActions::GetDataLength() const
10919 {
10920   PINDEX length = 0;
10921   if (HasOptionalField(e_keepActive))
10922     length += m_keepActive.GetObjectLength();
10923   if (HasOptionalField(e_eventDM))
10924     length += m_eventDM.GetObjectLength();
10925   if (HasOptionalField(e_secondEvent))
10926     length += m_secondEvent.GetObjectLength();
10927   if (HasOptionalField(e_signalsDescriptor))
10928     length += m_signalsDescriptor.GetObjectLength();
10929   return length;
10930 }
10931
10932
10933 BOOL H248_RequestedActions::Decode(PASN_Stream & strm)
10934 {
10935   if (!PreambleDecode(strm))
10936     return FALSE;
10937
10938   if (HasOptionalField(e_keepActive) && !m_keepActive.Decode(strm))
10939     return FALSE;
10940   if (HasOptionalField(e_eventDM) && !m_eventDM.Decode(strm))
10941     return FALSE;
10942   if (HasOptionalField(e_secondEvent) && !m_secondEvent.Decode(strm))
10943     return FALSE;
10944   if (HasOptionalField(e_signalsDescriptor) && !m_signalsDescriptor.Decode(strm))
10945     return FALSE;
10946
10947   return UnknownExtensionsDecode(strm);
10948 }
10949
10950
10951 void H248_RequestedActions::Encode(PASN_Stream & strm) const
10952 {
10953   PreambleEncode(strm);
10954
10955   if (HasOptionalField(e_keepActive))
10956     m_keepActive.Encode(strm);
10957   if (HasOptionalField(e_eventDM))
10958     m_eventDM.Encode(strm);
10959   if (HasOptionalField(e_secondEvent))
10960     m_secondEvent.Encode(strm);
10961   if (HasOptionalField(e_signalsDescriptor))
10962     m_signalsDescriptor.Encode(strm);
10963
10964   UnknownExtensionsEncode(strm);
10965 }
10966
10967
10968 PObject * H248_RequestedActions::Clone() const
10969 {
10970 #ifndef PASN_LEANANDMEAN
10971   PAssert(IsClass(H248_RequestedActions::Class()), PInvalidCast);
10972 #endif
10973   return new H248_RequestedActions(*this);
10974 }
10975
10976
10977 //
10978 // SecondRequestedEvent
10979 //
10980
10981 H248_SecondRequestedEvent::H248_SecondRequestedEvent(unsigned tag, PASN_Object::TagClass tagClass)
10982   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
10983 {
10984 }
10985
10986
10987 #ifndef PASN_NOPRINTON
10988 void H248_SecondRequestedEvent::PrintOn(ostream & strm) const
10989 {
10990   int indent = strm.precision() + 2;
10991   strm << "{\n";
10992   strm << setw(indent+11) << "pkgdName = " << setprecision(indent) << m_pkgdName << '\n';
10993   if (HasOptionalField(e_streamID))
10994     strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
10995   if (HasOptionalField(e_eventAction))
10996     strm << setw(indent+14) << "eventAction = " << setprecision(indent) << m_eventAction << '\n';
10997   strm << setw(indent+12) << "evParList = " << setprecision(indent) << m_evParList << '\n';
10998   strm << setw(indent-1) << setprecision(indent-2) << "}";
10999 }
11000 #endif
11001
11002
11003 PObject::Comparison H248_SecondRequestedEvent::Compare(const PObject & obj) const
11004 {
11005 #ifndef PASN_LEANANDMEAN
11006   PAssert(PIsDescendant(&obj, H248_SecondRequestedEvent), PInvalidCast);
11007 #endif
11008   const H248_SecondRequestedEvent & other = (const H248_SecondRequestedEvent &)obj;
11009
11010   Comparison result;
11011
11012   if ((result = m_pkgdName.Compare(other.m_pkgdName)) != EqualTo)
11013     return result;
11014   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
11015     return result;
11016   if ((result = m_eventAction.Compare(other.m_eventAction)) != EqualTo)
11017     return result;
11018   if ((result = m_evParList.Compare(other.m_evParList)) != EqualTo)
11019     return result;
11020
11021   return PASN_Sequence::Compare(other);
11022 }
11023
11024
11025 PINDEX H248_SecondRequestedEvent::GetDataLength() const
11026 {
11027   PINDEX length = 0;
11028   length += m_pkgdName.GetObjectLength();
11029   if (HasOptionalField(e_streamID))
11030     length += m_streamID.GetObjectLength();
11031   if (HasOptionalField(e_eventAction))
11032     length += m_eventAction.GetObjectLength();
11033   length += m_evParList.GetObjectLength();
11034   return length;
11035 }
11036
11037
11038 BOOL H248_SecondRequestedEvent::Decode(PASN_Stream & strm)
11039 {
11040   if (!PreambleDecode(strm))
11041     return FALSE;
11042
11043   if (!m_pkgdName.Decode(strm))
11044     return FALSE;
11045   if (HasOptionalField(e_streamID) && !m_streamID.Decode(strm))
11046     return FALSE;
11047   if (HasOptionalField(e_eventAction) && !m_eventAction.Decode(strm))
11048     return FALSE;
11049   if (!m_evParList.Decode(strm))
11050     return FALSE;
11051
11052   return UnknownExtensionsDecode(strm);
11053 }
11054
11055
11056 void H248_SecondRequestedEvent::Encode(PASN_Stream & strm) const
11057 {
11058   PreambleEncode(strm);
11059
11060   m_pkgdName.Encode(strm);
11061   if (HasOptionalField(e_streamID))
11062     m_streamID.Encode(strm);
11063   if (HasOptionalField(e_eventAction))
11064     m_eventAction.Encode(strm);
11065   m_evParList.Encode(strm);
11066
11067   UnknownExtensionsEncode(strm);
11068 }
11069
11070
11071 PObject * H248_SecondRequestedEvent::Clone() const
11072 {
11073 #ifndef PASN_LEANANDMEAN
11074   PAssert(IsClass(H248_SecondRequestedEvent::Class()), PInvalidCast);
11075 #endif
11076   return new H248_SecondRequestedEvent(*this);
11077 }
11078
11079
11080 //
11081 // ModemDescriptor
11082 //
11083
11084 H248_ModemDescriptor::H248_ModemDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
11085   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
11086 {
11087 }
11088
11089
11090 #ifndef PASN_NOPRINTON
11091 void H248_ModemDescriptor::PrintOn(ostream & strm) const
11092 {
11093   int indent = strm.precision() + 2;
11094   strm << "{\n";
11095   strm << setw(indent+6) << "mtl = " << setprecision(indent) << m_mtl << '\n';
11096   strm << setw(indent+6) << "mpl = " << setprecision(indent) << m_mpl << '\n';
11097   if (HasOptionalField(e_nonStandardData))
11098     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
11099   strm << setw(indent-1) << setprecision(indent-2) << "}";
11100 }
11101 #endif
11102
11103
11104 PObject::Comparison H248_ModemDescriptor::Compare(const PObject & obj) const
11105 {
11106 #ifndef PASN_LEANANDMEAN
11107   PAssert(PIsDescendant(&obj, H248_ModemDescriptor), PInvalidCast);
11108 #endif
11109   const H248_ModemDescriptor & other = (const H248_ModemDescriptor &)obj;
11110
11111   Comparison result;
11112
11113   if ((result = m_mtl.Compare(other.m_mtl)) != EqualTo)
11114     return result;
11115   if ((result = m_mpl.Compare(other.m_mpl)) != EqualTo)
11116     return result;
11117   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
11118     return result;
11119
11120   return PASN_Sequence::Compare(other);
11121 }
11122
11123
11124 PINDEX H248_ModemDescriptor::GetDataLength() const
11125 {
11126   PINDEX length = 0;
11127   length += m_mtl.GetObjectLength();
11128   length += m_mpl.GetObjectLength();
11129   if (HasOptionalField(e_nonStandardData))
11130     length += m_nonStandardData.GetObjectLength();
11131   return length;
11132 }
11133
11134
11135 BOOL H248_ModemDescriptor::Decode(PASN_Stream & strm)
11136 {
11137   if (!PreambleDecode(strm))
11138     return FALSE;
11139
11140   if (!m_mtl.Decode(strm))
11141     return FALSE;
11142   if (!m_mpl.Decode(strm))
11143     return FALSE;
11144   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
11145     return FALSE;
11146
11147   return UnknownExtensionsDecode(strm);
11148 }
11149
11150
11151 void H248_ModemDescriptor::Encode(PASN_Stream & strm) const
11152 {
11153   PreambleEncode(strm);
11154
11155   m_mtl.Encode(strm);
11156   m_mpl.Encode(strm);
11157   if (HasOptionalField(e_nonStandardData))
11158     m_nonStandardData.Encode(strm);
11159
11160   UnknownExtensionsEncode(strm);
11161 }
11162
11163
11164 PObject * H248_ModemDescriptor::Clone() const
11165 {
11166 #ifndef PASN_LEANANDMEAN
11167   PAssert(IsClass(H248_ModemDescriptor::Class()), PInvalidCast);
11168 #endif
11169   return new H248_ModemDescriptor(*this);
11170 }
11171
11172
11173 //
11174 // ServiceChangeParm
11175 //
11176
11177 H248_ServiceChangeParm::H248_ServiceChangeParm(unsigned tag, PASN_Object::TagClass tagClass)
11178   : PASN_Sequence(tag, tagClass, 7, TRUE, 1)
11179 {
11180   m_serviceChangeVersion.SetConstraints(PASN_Object::FixedConstraint, 0, 99);
11181   m_serviceChangeDelay.SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
11182 }
11183
11184
11185 #ifndef PASN_NOPRINTON
11186 void H248_ServiceChangeParm::PrintOn(ostream & strm) const
11187 {
11188   int indent = strm.precision() + 2;
11189   strm << "{\n";
11190   strm << setw(indent+22) << "serviceChangeMethod = " << setprecision(indent) << m_serviceChangeMethod << '\n';
11191   if (HasOptionalField(e_serviceChangeAddress))
11192     strm << setw(indent+23) << "serviceChangeAddress = " << setprecision(indent) << m_serviceChangeAddress << '\n';
11193   if (HasOptionalField(e_serviceChangeVersion))
11194     strm << setw(indent+23) << "serviceChangeVersion = " << setprecision(indent) << m_serviceChangeVersion << '\n';
11195   if (HasOptionalField(e_serviceChangeProfile))
11196     strm << setw(indent+23) << "serviceChangeProfile = " << setprecision(indent) << m_serviceChangeProfile << '\n';
11197   strm << setw(indent+22) << "serviceChangeReason = " << setprecision(indent) << m_serviceChangeReason << '\n';
11198   if (HasOptionalField(e_serviceChangeDelay))
11199     strm << setw(indent+21) << "serviceChangeDelay = " << setprecision(indent) << m_serviceChangeDelay << '\n';
11200   if (HasOptionalField(e_serviceChangeMgcId))
11201     strm << setw(indent+21) << "serviceChangeMgcId = " << setprecision(indent) << m_serviceChangeMgcId << '\n';
11202   if (HasOptionalField(e_timeStamp))
11203     strm << setw(indent+12) << "timeStamp = " << setprecision(indent) << m_timeStamp << '\n';
11204   if (HasOptionalField(e_nonStandardData))
11205     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
11206   if (HasOptionalField(e_serviceChangeInfo))
11207     strm << setw(indent+20) << "serviceChangeInfo = " << setprecision(indent) << m_serviceChangeInfo << '\n';
11208   strm << setw(indent-1) << setprecision(indent-2) << "}";
11209 }
11210 #endif
11211
11212
11213 PObject::Comparison H248_ServiceChangeParm::Compare(const PObject & obj) const
11214 {
11215 #ifndef PASN_LEANANDMEAN
11216   PAssert(PIsDescendant(&obj, H248_ServiceChangeParm), PInvalidCast);
11217 #endif
11218   const H248_ServiceChangeParm & other = (const H248_ServiceChangeParm &)obj;
11219
11220   Comparison result;
11221
11222   if ((result = m_serviceChangeMethod.Compare(other.m_serviceChangeMethod)) != EqualTo)
11223     return result;
11224   if ((result = m_serviceChangeAddress.Compare(other.m_serviceChangeAddress)) != EqualTo)
11225     return result;
11226   if ((result = m_serviceChangeVersion.Compare(other.m_serviceChangeVersion)) != EqualTo)
11227     return result;
11228   if ((result = m_serviceChangeProfile.Compare(other.m_serviceChangeProfile)) != EqualTo)
11229     return result;
11230   if ((result = m_serviceChangeReason.Compare(other.m_serviceChangeReason)) != EqualTo)
11231     return result;
11232   if ((result = m_serviceChangeDelay.Compare(other.m_serviceChangeDelay)) != EqualTo)
11233     return result;
11234   if ((result = m_serviceChangeMgcId.Compare(other.m_serviceChangeMgcId)) != EqualTo)
11235     return result;
11236   if ((result = m_timeStamp.Compare(other.m_timeStamp)) != EqualTo)
11237     return result;
11238   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
11239     return result;
11240
11241   return PASN_Sequence::Compare(other);
11242 }
11243
11244
11245 PINDEX H248_ServiceChangeParm::GetDataLength() const
11246 {
11247   PINDEX length = 0;
11248   length += m_serviceChangeMethod.GetObjectLength();
11249   if (HasOptionalField(e_serviceChangeAddress))
11250     length += m_serviceChangeAddress.GetObjectLength();
11251   if (HasOptionalField(e_serviceChangeVersion))
11252     length += m_serviceChangeVersion.GetObjectLength();
11253   if (HasOptionalField(e_serviceChangeProfile))
11254     length += m_serviceChangeProfile.GetObjectLength();
11255   length += m_serviceChangeReason.GetObjectLength();
11256   if (HasOptionalField(e_serviceChangeDelay))
11257     length += m_serviceChangeDelay.GetObjectLength();
11258   if (HasOptionalField(e_serviceChangeMgcId))
11259     length += m_serviceChangeMgcId.GetObjectLength();
11260   if (HasOptionalField(e_timeStamp))
11261     length += m_timeStamp.GetObjectLength();
11262   if (HasOptionalField(e_nonStandardData))
11263     length += m_nonStandardData.GetObjectLength();
11264   return length;
11265 }
11266
11267
11268 BOOL H248_ServiceChangeParm::Decode(PASN_Stream & strm)
11269 {
11270   if (!PreambleDecode(strm))
11271     return FALSE;
11272
11273   if (!m_serviceChangeMethod.Decode(strm))
11274     return FALSE;
11275   if (HasOptionalField(e_serviceChangeAddress) && !m_serviceChangeAddress.Decode(strm))
11276     return FALSE;
11277   if (HasOptionalField(e_serviceChangeVersion) && !m_serviceChangeVersion.Decode(strm))
11278     return FALSE;
11279   if (HasOptionalField(e_serviceChangeProfile) && !m_serviceChangeProfile.Decode(strm))
11280     return FALSE;
11281   if (!m_serviceChangeReason.Decode(strm))
11282     return FALSE;
11283   if (HasOptionalField(e_serviceChangeDelay) && !m_serviceChangeDelay.Decode(strm))
11284     return FALSE;
11285   if (HasOptionalField(e_serviceChangeMgcId) && !m_serviceChangeMgcId.Decode(strm))
11286     return FALSE;
11287   if (HasOptionalField(e_timeStamp) && !m_timeStamp.Decode(strm))
11288     return FALSE;
11289   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
11290     return FALSE;
11291   if (!KnownExtensionDecode(strm, e_serviceChangeInfo, m_serviceChangeInfo))
11292     return FALSE;
11293
11294   return UnknownExtensionsDecode(strm);
11295 }
11296
11297
11298 void H248_ServiceChangeParm::Encode(PASN_Stream & strm) const
11299 {
11300   PreambleEncode(strm);
11301
11302   m_serviceChangeMethod.Encode(strm);
11303   if (HasOptionalField(e_serviceChangeAddress))
11304     m_serviceChangeAddress.Encode(strm);
11305   if (HasOptionalField(e_serviceChangeVersion))
11306     m_serviceChangeVersion.Encode(strm);
11307   if (HasOptionalField(e_serviceChangeProfile))
11308     m_serviceChangeProfile.Encode(strm);
11309   m_serviceChangeReason.Encode(strm);
11310   if (HasOptionalField(e_serviceChangeDelay))
11311     m_serviceChangeDelay.Encode(strm);
11312   if (HasOptionalField(e_serviceChangeMgcId))
11313     m_serviceChangeMgcId.Encode(strm);
11314   if (HasOptionalField(e_timeStamp))
11315     m_timeStamp.Encode(strm);
11316   if (HasOptionalField(e_nonStandardData))
11317     m_nonStandardData.Encode(strm);
11318   KnownExtensionEncode(strm, e_serviceChangeInfo, m_serviceChangeInfo);
11319
11320   UnknownExtensionsEncode(strm);
11321 }
11322
11323
11324 PObject * H248_ServiceChangeParm::Clone() const
11325 {
11326 #ifndef PASN_LEANANDMEAN
11327   PAssert(IsClass(H248_ServiceChangeParm::Class()), PInvalidCast);
11328 #endif
11329   return new H248_ServiceChangeParm(*this);
11330 }
11331
11332
11333 //
11334 // IndAudStreamDescriptor
11335 //
11336
11337 H248_IndAudStreamDescriptor::H248_IndAudStreamDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
11338   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
11339 {
11340 }
11341
11342
11343 #ifndef PASN_NOPRINTON
11344 void H248_IndAudStreamDescriptor::PrintOn(ostream & strm) const
11345 {
11346   int indent = strm.precision() + 2;
11347   strm << "{\n";
11348   strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
11349   strm << setw(indent+14) << "streamParms = " << setprecision(indent) << m_streamParms << '\n';
11350   strm << setw(indent-1) << setprecision(indent-2) << "}";
11351 }
11352 #endif
11353
11354
11355 PObject::Comparison H248_IndAudStreamDescriptor::Compare(const PObject & obj) const
11356 {
11357 #ifndef PASN_LEANANDMEAN
11358   PAssert(PIsDescendant(&obj, H248_IndAudStreamDescriptor), PInvalidCast);
11359 #endif
11360   const H248_IndAudStreamDescriptor & other = (const H248_IndAudStreamDescriptor &)obj;
11361
11362   Comparison result;
11363
11364   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
11365     return result;
11366   if ((result = m_streamParms.Compare(other.m_streamParms)) != EqualTo)
11367     return result;
11368
11369   return PASN_Sequence::Compare(other);
11370 }
11371
11372
11373 PINDEX H248_IndAudStreamDescriptor::GetDataLength() const
11374 {
11375   PINDEX length = 0;
11376   length += m_streamID.GetObjectLength();
11377   length += m_streamParms.GetObjectLength();
11378   return length;
11379 }
11380
11381
11382 BOOL H248_IndAudStreamDescriptor::Decode(PASN_Stream & strm)
11383 {
11384   if (!PreambleDecode(strm))
11385     return FALSE;
11386
11387   if (!m_streamID.Decode(strm))
11388     return FALSE;
11389   if (!m_streamParms.Decode(strm))
11390     return FALSE;
11391
11392   return UnknownExtensionsDecode(strm);
11393 }
11394
11395
11396 void H248_IndAudStreamDescriptor::Encode(PASN_Stream & strm) const
11397 {
11398   PreambleEncode(strm);
11399
11400   m_streamID.Encode(strm);
11401   m_streamParms.Encode(strm);
11402
11403   UnknownExtensionsEncode(strm);
11404 }
11405
11406
11407 PObject * H248_IndAudStreamDescriptor::Clone() const
11408 {
11409 #ifndef PASN_LEANANDMEAN
11410   PAssert(IsClass(H248_IndAudStreamDescriptor::Class()), PInvalidCast);
11411 #endif
11412   return new H248_IndAudStreamDescriptor(*this);
11413 }
11414
11415
11416 //
11417 // ServiceChangeRequest
11418 //
11419
11420 H248_ServiceChangeRequest::H248_ServiceChangeRequest(unsigned tag, PASN_Object::TagClass tagClass)
11421   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
11422 {
11423 }
11424
11425
11426 #ifndef PASN_NOPRINTON
11427 void H248_ServiceChangeRequest::PrintOn(ostream & strm) const
11428 {
11429   int indent = strm.precision() + 2;
11430   strm << "{\n";
11431   strm << setw(indent+16) << "terminationID = " << setprecision(indent) << m_terminationID << '\n';
11432   strm << setw(indent+21) << "serviceChangeParms = " << setprecision(indent) << m_serviceChangeParms << '\n';
11433   strm << setw(indent-1) << setprecision(indent-2) << "}";
11434 }
11435 #endif
11436
11437
11438 PObject::Comparison H248_ServiceChangeRequest::Compare(const PObject & obj) const
11439 {
11440 #ifndef PASN_LEANANDMEAN
11441   PAssert(PIsDescendant(&obj, H248_ServiceChangeRequest), PInvalidCast);
11442 #endif
11443   const H248_ServiceChangeRequest & other = (const H248_ServiceChangeRequest &)obj;
11444
11445   Comparison result;
11446
11447   if ((result = m_terminationID.Compare(other.m_terminationID)) != EqualTo)
11448     return result;
11449   if ((result = m_serviceChangeParms.Compare(other.m_serviceChangeParms)) != EqualTo)
11450     return result;
11451
11452   return PASN_Sequence::Compare(other);
11453 }
11454
11455
11456 PINDEX H248_ServiceChangeRequest::GetDataLength() const
11457 {
11458   PINDEX length = 0;
11459   length += m_terminationID.GetObjectLength();
11460   length += m_serviceChangeParms.GetObjectLength();
11461   return length;
11462 }
11463
11464
11465 BOOL H248_ServiceChangeRequest::Decode(PASN_Stream & strm)
11466 {
11467   if (!PreambleDecode(strm))
11468     return FALSE;
11469
11470   if (!m_terminationID.Decode(strm))
11471     return FALSE;
11472   if (!m_serviceChangeParms.Decode(strm))
11473     return FALSE;
11474
11475   return UnknownExtensionsDecode(strm);
11476 }
11477
11478
11479 void H248_ServiceChangeRequest::Encode(PASN_Stream & strm) const
11480 {
11481   PreambleEncode(strm);
11482
11483   m_terminationID.Encode(strm);
11484   m_serviceChangeParms.Encode(strm);
11485
11486   UnknownExtensionsEncode(strm);
11487 }
11488
11489
11490 PObject * H248_ServiceChangeRequest::Clone() const
11491 {
11492 #ifndef PASN_LEANANDMEAN
11493   PAssert(IsClass(H248_ServiceChangeRequest::Class()), PInvalidCast);
11494 #endif
11495   return new H248_ServiceChangeRequest(*this);
11496 }
11497
11498
11499 //
11500 // StreamDescriptor
11501 //
11502
11503 H248_StreamDescriptor::H248_StreamDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
11504   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
11505 {
11506 }
11507
11508
11509 #ifndef PASN_NOPRINTON
11510 void H248_StreamDescriptor::PrintOn(ostream & strm) const
11511 {
11512   int indent = strm.precision() + 2;
11513   strm << "{\n";
11514   strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
11515   strm << setw(indent+14) << "streamParms = " << setprecision(indent) << m_streamParms << '\n';
11516   strm << setw(indent-1) << setprecision(indent-2) << "}";
11517 }
11518 #endif
11519
11520
11521 PObject::Comparison H248_StreamDescriptor::Compare(const PObject & obj) const
11522 {
11523 #ifndef PASN_LEANANDMEAN
11524   PAssert(PIsDescendant(&obj, H248_StreamDescriptor), PInvalidCast);
11525 #endif
11526   const H248_StreamDescriptor & other = (const H248_StreamDescriptor &)obj;
11527
11528   Comparison result;
11529
11530   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
11531     return result;
11532   if ((result = m_streamParms.Compare(other.m_streamParms)) != EqualTo)
11533     return result;
11534
11535   return PASN_Sequence::Compare(other);
11536 }
11537
11538
11539 PINDEX H248_StreamDescriptor::GetDataLength() const
11540 {
11541   PINDEX length = 0;
11542   length += m_streamID.GetObjectLength();
11543   length += m_streamParms.GetObjectLength();
11544   return length;
11545 }
11546
11547
11548 BOOL H248_StreamDescriptor::Decode(PASN_Stream & strm)
11549 {
11550   if (!PreambleDecode(strm))
11551     return FALSE;
11552
11553   if (!m_streamID.Decode(strm))
11554     return FALSE;
11555   if (!m_streamParms.Decode(strm))
11556     return FALSE;
11557
11558   return UnknownExtensionsDecode(strm);
11559 }
11560
11561
11562 void H248_StreamDescriptor::Encode(PASN_Stream & strm) const
11563 {
11564   PreambleEncode(strm);
11565
11566   m_streamID.Encode(strm);
11567   m_streamParms.Encode(strm);
11568
11569   UnknownExtensionsEncode(strm);
11570 }
11571
11572
11573 PObject * H248_StreamDescriptor::Clone() const
11574 {
11575 #ifndef PASN_LEANANDMEAN
11576   PAssert(IsClass(H248_StreamDescriptor::Class()), PInvalidCast);
11577 #endif
11578   return new H248_StreamDescriptor(*this);
11579 }
11580
11581
11582 //
11583 // RequestedEvent
11584 //
11585
11586 H248_RequestedEvent::H248_RequestedEvent(unsigned tag, PASN_Object::TagClass tagClass)
11587   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
11588 {
11589 }
11590
11591
11592 #ifndef PASN_NOPRINTON
11593 void H248_RequestedEvent::PrintOn(ostream & strm) const
11594 {
11595   int indent = strm.precision() + 2;
11596   strm << "{\n";
11597   strm << setw(indent+11) << "pkgdName = " << setprecision(indent) << m_pkgdName << '\n';
11598   if (HasOptionalField(e_streamID))
11599     strm << setw(indent+11) << "streamID = " << setprecision(indent) << m_streamID << '\n';
11600   if (HasOptionalField(e_eventAction))
11601     strm << setw(indent+14) << "eventAction = " << setprecision(indent) << m_eventAction << '\n';
11602   strm << setw(indent+12) << "evParList = " << setprecision(indent) << m_evParList << '\n';
11603   strm << setw(indent-1) << setprecision(indent-2) << "}";
11604 }
11605 #endif
11606
11607
11608 PObject::Comparison H248_RequestedEvent::Compare(const PObject & obj) const
11609 {
11610 #ifndef PASN_LEANANDMEAN
11611   PAssert(PIsDescendant(&obj, H248_RequestedEvent), PInvalidCast);
11612 #endif
11613   const H248_RequestedEvent & other = (const H248_RequestedEvent &)obj;
11614
11615   Comparison result;
11616
11617   if ((result = m_pkgdName.Compare(other.m_pkgdName)) != EqualTo)
11618     return result;
11619   if ((result = m_streamID.Compare(other.m_streamID)) != EqualTo)
11620     return result;
11621   if ((result = m_eventAction.Compare(other.m_eventAction)) != EqualTo)
11622     return result;
11623   if ((result = m_evParList.Compare(other.m_evParList)) != EqualTo)
11624     return result;
11625
11626   return PASN_Sequence::Compare(other);
11627 }
11628
11629
11630 PINDEX H248_RequestedEvent::GetDataLength() const
11631 {
11632   PINDEX length = 0;
11633   length += m_pkgdName.GetObjectLength();
11634   if (HasOptionalField(e_streamID))
11635     length += m_streamID.GetObjectLength();
11636   if (HasOptionalField(e_eventAction))
11637     length += m_eventAction.GetObjectLength();
11638   length += m_evParList.GetObjectLength();
11639   return length;
11640 }
11641
11642
11643 BOOL H248_RequestedEvent::Decode(PASN_Stream & strm)
11644 {
11645   if (!PreambleDecode(strm))
11646     return FALSE;
11647
11648   if (!m_pkgdName.Decode(strm))
11649     return FALSE;
11650   if (HasOptionalField(e_streamID) && !m_streamID.Decode(strm))
11651     return FALSE;
11652   if (HasOptionalField(e_eventAction) && !m_eventAction.Decode(strm))
11653     return FALSE;
11654   if (!m_evParList.Decode(strm))
11655     return FALSE;
11656
11657   return UnknownExtensionsDecode(strm);
11658 }
11659
11660
11661 void H248_RequestedEvent::Encode(PASN_Stream & strm) const
11662 {
11663   PreambleEncode(strm);
11664
11665   m_pkgdName.Encode(strm);
11666   if (HasOptionalField(e_streamID))
11667     m_streamID.Encode(strm);
11668   if (HasOptionalField(e_eventAction))
11669     m_eventAction.Encode(strm);
11670   m_evParList.Encode(strm);
11671
11672   UnknownExtensionsEncode(strm);
11673 }
11674
11675
11676 PObject * H248_RequestedEvent::Clone() const
11677 {
11678 #ifndef PASN_LEANANDMEAN
11679   PAssert(IsClass(H248_RequestedEvent::Class()), PInvalidCast);
11680 #endif
11681   return new H248_RequestedEvent(*this);
11682 }
11683
11684
11685 #endif // if ! H323_DISABLE_H248
11686
11687
11688 // End of h248.cxx