channels/h323/cisco-h225.cxx

   1 //
   2 // cisco-h225.cxx
   3 //
   4 // Code automatically generated by asnparse.
   5 //
   6
   7 #ifdef P_USE_PRAGMA
   8 #pragma implementation "cisco-h225.h"
   9 #endif
  10
  11 #include <ptlib.h>
  12 #include "cisco-h225.h"
  13
  14 #define new PNEW
  15
  16
  17 #if ! H323_DISABLE_CISCO_H225
  18
  19 //
  20 // RedirectIEinfo
  21 //
  22
  23 CISCO_H225_RedirectIEinfo::CISCO_H225_RedirectIEinfo(unsigned tag, PASN_Object::TagClass tagClass)
  24   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  25 {
  26 }
  27
  28
  29 #ifndef PASN_NOPRINTON
  30 void CISCO_H225_RedirectIEinfo::PrintOn(ostream & strm) const
  31 {
  32   int indent = strm.precision() + 2;
  33   strm << "{\n";
  34   strm << setw(indent+13) << "redirectIE = " << setprecision(indent) << m_redirectIE << '\n';
  35   strm << setw(indent-1) << setprecision(indent-2) << "}";
  36 }
  37 #endif
  38
  39
  40 PObject::Comparison CISCO_H225_RedirectIEinfo::Compare(const PObject & obj) const
  41 {
  42 #ifndef PASN_LEANANDMEAN
  43   PAssert(PIsDescendant(&obj, CISCO_H225_RedirectIEinfo), PInvalidCast);
  44 #endif
  45   const CISCO_H225_RedirectIEinfo & other = (const CISCO_H225_RedirectIEinfo &)obj;
  46
  47   Comparison result;
  48
  49   if ((result = m_redirectIE.Compare(other.m_redirectIE)) != EqualTo)
  50     return result;
  51
  52   return PASN_Sequence::Compare(other);
  53 }
  54
  55
  56 PINDEX CISCO_H225_RedirectIEinfo::GetDataLength() const
  57 {
  58   PINDEX length = 0;
  59   length += m_redirectIE.GetObjectLength();
  60   return length;
  61 }
  62
  63
  64 BOOL CISCO_H225_RedirectIEinfo::Decode(PASN_Stream & strm)
  65 {
  66   if (!PreambleDecode(strm))
  67     return FALSE;
  68
  69   if (!m_redirectIE.Decode(strm))
  70     return FALSE;
  71
  72   return UnknownExtensionsDecode(strm);
  73 }
  74
  75
  76 void CISCO_H225_RedirectIEinfo::Encode(PASN_Stream & strm) const
  77 {
  78   PreambleEncode(strm);
  79
  80   m_redirectIE.Encode(strm);
  81
  82   UnknownExtensionsEncode(strm);
  83 }
  84
  85
  86 PObject * CISCO_H225_RedirectIEinfo::Clone() const
  87 {
  88 #ifndef PASN_LEANANDMEAN
  89   PAssert(IsClass(CISCO_H225_RedirectIEinfo::Class()), PInvalidCast);
  90 #endif
  91   return new CISCO_H225_RedirectIEinfo(*this);
  92 }
  93
  94
  95 //
  96 // ProgIndIEinfo
  97 //
  98
  99 CISCO_H225_ProgIndIEinfo::CISCO_H225_ProgIndIEinfo(unsigned tag, PASN_Object::TagClass tagClass)
 100   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 101 {
 102 }
 103
 104
 105 #ifndef PASN_NOPRINTON
 106 void CISCO_H225_ProgIndIEinfo::PrintOn(ostream & strm) const
 107 {
 108   int indent = strm.precision() + 2;
 109   strm << "{\n";
 110   strm << setw(indent+12) << "progIndIE = " << setprecision(indent) << m_progIndIE << '\n';
 111   strm << setw(indent-1) << setprecision(indent-2) << "}";
 112 }
 113 #endif
 114
 115
 116 PObject::Comparison CISCO_H225_ProgIndIEinfo::Compare(const PObject & obj) const
 117 {
 118 #ifndef PASN_LEANANDMEAN
 119   PAssert(PIsDescendant(&obj, CISCO_H225_ProgIndIEinfo), PInvalidCast);
 120 #endif
 121   const CISCO_H225_ProgIndIEinfo & other = (const CISCO_H225_ProgIndIEinfo &)obj;
 122
 123   Comparison result;
 124
 125   if ((result = m_progIndIE.Compare(other.m_progIndIE)) != EqualTo)
 126     return result;
 127
 128   return PASN_Sequence::Compare(other);
 129 }
 130
 131
 132 PINDEX CISCO_H225_ProgIndIEinfo::GetDataLength() const
 133 {
 134   PINDEX length = 0;
 135   length += m_progIndIE.GetObjectLength();
 136   return length;
 137 }
 138
 139
 140 BOOL CISCO_H225_ProgIndIEinfo::Decode(PASN_Stream & strm)
 141 {
 142   if (!PreambleDecode(strm))
 143     return FALSE;
 144
 145   if (!m_progIndIE.Decode(strm))
 146     return FALSE;
 147
 148   return UnknownExtensionsDecode(strm);
 149 }
 150
 151
 152 void CISCO_H225_ProgIndIEinfo::Encode(PASN_Stream & strm) const
 153 {
 154   PreambleEncode(strm);
 155
 156   m_progIndIE.Encode(strm);
 157
 158   UnknownExtensionsEncode(strm);
 159 }
 160
 161
 162 PObject * CISCO_H225_ProgIndIEinfo::Clone() const
 163 {
 164 #ifndef PASN_LEANANDMEAN
 165   PAssert(IsClass(CISCO_H225_ProgIndIEinfo::Class()), PInvalidCast);
 166 #endif
 167   return new CISCO_H225_ProgIndIEinfo(*this);
 168 }
 169
 170
 171 //
 172 // QsigNonStdInfo
 173 //
 174
 175 CISCO_H225_QsigNonStdInfo::CISCO_H225_QsigNonStdInfo(unsigned tag, PASN_Object::TagClass tagClass)
 176   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 177 {
 178 }
 179
 180
 181 #ifndef PASN_NOPRINTON
 182 void CISCO_H225_QsigNonStdInfo::PrintOn(ostream & strm) const
 183 {
 184   int indent = strm.precision() + 2;
 185   strm << "{\n";
 186   strm << setw(indent+6) << "iei = " << setprecision(indent) << m_iei << '\n';
 187   strm << setw(indent+10) << "rawMesg = " << setprecision(indent) << m_rawMesg << '\n';
 188   strm << setw(indent-1) << setprecision(indent-2) << "}";
 189 }
 190 #endif
 191
 192
 193 PObject::Comparison CISCO_H225_QsigNonStdInfo::Compare(const PObject & obj) const
 194 {
 195 #ifndef PASN_LEANANDMEAN
 196   PAssert(PIsDescendant(&obj, CISCO_H225_QsigNonStdInfo), PInvalidCast);
 197 #endif
 198   const CISCO_H225_QsigNonStdInfo & other = (const CISCO_H225_QsigNonStdInfo &)obj;
 199
 200   Comparison result;
 201
 202   if ((result = m_iei.Compare(other.m_iei)) != EqualTo)
 203     return result;
 204   if ((result = m_rawMesg.Compare(other.m_rawMesg)) != EqualTo)
 205     return result;
 206
 207   return PASN_Sequence::Compare(other);
 208 }
 209
 210
 211 PINDEX CISCO_H225_QsigNonStdInfo::GetDataLength() const
 212 {
 213   PINDEX length = 0;
 214   length += m_iei.GetObjectLength();
 215   length += m_rawMesg.GetObjectLength();
 216   return length;
 217 }
 218
 219
 220 BOOL CISCO_H225_QsigNonStdInfo::Decode(PASN_Stream & strm)
 221 {
 222   if (!PreambleDecode(strm))
 223     return FALSE;
 224
 225   if (!m_iei.Decode(strm))
 226     return FALSE;
 227   if (!m_rawMesg.Decode(strm))
 228     return FALSE;
 229
 230   return UnknownExtensionsDecode(strm);
 231 }
 232
 233
 234 void CISCO_H225_QsigNonStdInfo::Encode(PASN_Stream & strm) const
 235 {
 236   PreambleEncode(strm);
 237
 238   m_iei.Encode(strm);
 239   m_rawMesg.Encode(strm);
 240
 241   UnknownExtensionsEncode(strm);
 242 }
 243
 244
 245 PObject * CISCO_H225_QsigNonStdInfo::Clone() const
 246 {
 247 #ifndef PASN_LEANANDMEAN
 248   PAssert(IsClass(CISCO_H225_QsigNonStdInfo::Class()), PInvalidCast);
 249 #endif
 250   return new CISCO_H225_QsigNonStdInfo(*this);
 251 }
 252
 253
 254 //
 255 // CallMgrParam
 256 //
 257
 258 CISCO_H225_CallMgrParam::CISCO_H225_CallMgrParam(unsigned tag, PASN_Object::TagClass tagClass)
 259   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 260 {
 261 }
 262
 263
 264 #ifndef PASN_NOPRINTON
 265 void CISCO_H225_CallMgrParam::PrintOn(ostream & strm) const
 266 {
 267   int indent = strm.precision() + 2;
 268   strm << "{\n";
 269   strm << setw(indent+22) << "interclusterVersion = " << setprecision(indent) << m_interclusterVersion << '\n';
 270   strm << setw(indent+15) << "enterpriseID = " << setprecision(indent) << m_enterpriseID << '\n';
 271   strm << setw(indent-1) << setprecision(indent-2) << "}";
 272 }
 273 #endif
 274
 275
 276 PObject::Comparison CISCO_H225_CallMgrParam::Compare(const PObject & obj) const
 277 {
 278 #ifndef PASN_LEANANDMEAN
 279   PAssert(PIsDescendant(&obj, CISCO_H225_CallMgrParam), PInvalidCast);
 280 #endif
 281   const CISCO_H225_CallMgrParam & other = (const CISCO_H225_CallMgrParam &)obj;
 282
 283   Comparison result;
 284
 285   if ((result = m_interclusterVersion.Compare(other.m_interclusterVersion)) != EqualTo)
 286     return result;
 287   if ((result = m_enterpriseID.Compare(other.m_enterpriseID)) != EqualTo)
 288     return result;
 289
 290   return PASN_Sequence::Compare(other);
 291 }
 292
 293
 294 PINDEX CISCO_H225_CallMgrParam::GetDataLength() const
 295 {
 296   PINDEX length = 0;
 297   length += m_interclusterVersion.GetObjectLength();
 298   length += m_enterpriseID.GetObjectLength();
 299   return length;
 300 }
 301
 302
 303 BOOL CISCO_H225_CallMgrParam::Decode(PASN_Stream & strm)
 304 {
 305   if (!PreambleDecode(strm))
 306     return FALSE;
 307
 308   if (!m_interclusterVersion.Decode(strm))
 309     return FALSE;
 310   if (!m_enterpriseID.Decode(strm))
 311     return FALSE;
 312
 313   return UnknownExtensionsDecode(strm);
 314 }
 315
 316
 317 void CISCO_H225_CallMgrParam::Encode(PASN_Stream & strm) const
 318 {
 319   PreambleEncode(strm);
 320
 321   m_interclusterVersion.Encode(strm);
 322   m_enterpriseID.Encode(strm);
 323
 324   UnknownExtensionsEncode(strm);
 325 }
 326
 327
 328 PObject * CISCO_H225_CallMgrParam::Clone() const
 329 {
 330 #ifndef PASN_LEANANDMEAN
 331   PAssert(IsClass(CISCO_H225_CallMgrParam::Class()), PInvalidCast);
 332 #endif
 333   return new CISCO_H225_CallMgrParam(*this);
 334 }
 335
 336
 337 //
 338 // CallPreserveParam
 339 //
 340
 341 CISCO_H225_CallPreserveParam::CISCO_H225_CallPreserveParam(unsigned tag, PASN_Object::TagClass tagClass)
 342   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 343 {
 344 }
 345
 346
 347 #ifndef PASN_NOPRINTON
 348 void CISCO_H225_CallPreserveParam::PrintOn(ostream & strm) const
 349 {
 350   int indent = strm.precision() + 2;
 351   strm << "{\n";
 352   strm << setw(indent+17) << "callPreserveIE = " << setprecision(indent) << m_callPreserveIE << '\n';
 353   strm << setw(indent-1) << setprecision(indent-2) << "}";
 354 }
 355 #endif
 356
 357
 358 PObject::Comparison CISCO_H225_CallPreserveParam::Compare(const PObject & obj) const
 359 {
 360 #ifndef PASN_LEANANDMEAN
 361   PAssert(PIsDescendant(&obj, CISCO_H225_CallPreserveParam), PInvalidCast);
 362 #endif
 363   const CISCO_H225_CallPreserveParam & other = (const CISCO_H225_CallPreserveParam &)obj;
 364
 365   Comparison result;
 366
 367   if ((result = m_callPreserveIE.Compare(other.m_callPreserveIE)) != EqualTo)
 368     return result;
 369
 370   return PASN_Sequence::Compare(other);
 371 }
 372
 373
 374 PINDEX CISCO_H225_CallPreserveParam::GetDataLength() const
 375 {
 376   PINDEX length = 0;
 377   length += m_callPreserveIE.GetObjectLength();
 378   return length;
 379 }
 380
 381
 382 BOOL CISCO_H225_CallPreserveParam::Decode(PASN_Stream & strm)
 383 {
 384   if (!PreambleDecode(strm))
 385     return FALSE;
 386
 387   if (!m_callPreserveIE.Decode(strm))
 388     return FALSE;
 389
 390   return UnknownExtensionsDecode(strm);
 391 }
 392
 393
 394 void CISCO_H225_CallPreserveParam::Encode(PASN_Stream & strm) const
 395 {
 396   PreambleEncode(strm);
 397
 398   m_callPreserveIE.Encode(strm);
 399
 400   UnknownExtensionsEncode(strm);
 401 }
 402
 403
 404 PObject * CISCO_H225_CallPreserveParam::Clone() const
 405 {
 406 #ifndef PASN_LEANANDMEAN
 407   PAssert(IsClass(CISCO_H225_CallPreserveParam::Class()), PInvalidCast);
 408 #endif
 409   return new CISCO_H225_CallPreserveParam(*this);
 410 }
 411
 412
 413 //
 414 // CallSignallingParam
 415 //
 416
 417 CISCO_H225_CallSignallingParam::CISCO_H225_CallSignallingParam(unsigned tag, PASN_Object::TagClass tagClass)
 418   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
 419 {
 420   m_connectedNumber.SetConstraints(PASN_Object::FixedConstraint, 1, 127);
 421 }
 422
 423
 424 #ifndef PASN_NOPRINTON
 425 void CISCO_H225_CallSignallingParam::PrintOn(ostream & strm) const
 426 {
 427   int indent = strm.precision() + 2;
 428   strm << "{\n";
 429   if (HasOptionalField(e_connectedNumber))
 430     strm << setw(indent+18) << "connectedNumber = " << setprecision(indent) << m_connectedNumber << '\n';
 431   strm << setw(indent-1) << setprecision(indent-2) << "}";
 432 }
 433 #endif
 434
 435
 436 PObject::Comparison CISCO_H225_CallSignallingParam::Compare(const PObject & obj) const
 437 {
 438 #ifndef PASN_LEANANDMEAN
 439   PAssert(PIsDescendant(&obj, CISCO_H225_CallSignallingParam), PInvalidCast);
 440 #endif
 441   const CISCO_H225_CallSignallingParam & other = (const CISCO_H225_CallSignallingParam &)obj;
 442
 443   Comparison result;
 444
 445   if ((result = m_connectedNumber.Compare(other.m_connectedNumber)) != EqualTo)
 446     return result;
 447
 448   return PASN_Sequence::Compare(other);
 449 }
 450
 451
 452 PINDEX CISCO_H225_CallSignallingParam::GetDataLength() const
 453 {
 454   PINDEX length = 0;
 455   if (HasOptionalField(e_connectedNumber))
 456     length += m_connectedNumber.GetObjectLength();
 457   return length;
 458 }
 459
 460
 461 BOOL CISCO_H225_CallSignallingParam::Decode(PASN_Stream & strm)
 462 {
 463   if (!PreambleDecode(strm))
 464     return FALSE;
 465
 466   if (HasOptionalField(e_connectedNumber) && !m_connectedNumber.Decode(strm))
 467     return FALSE;
 468
 469   return UnknownExtensionsDecode(strm);
 470 }
 471
 472
 473 void CISCO_H225_CallSignallingParam::Encode(PASN_Stream & strm) const
 474 {
 475   PreambleEncode(strm);
 476
 477   if (HasOptionalField(e_connectedNumber))
 478     m_connectedNumber.Encode(strm);
 479
 480   UnknownExtensionsEncode(strm);
 481 }
 482
 483
 484 PObject * CISCO_H225_CallSignallingParam::Clone() const
 485 {
 486 #ifndef PASN_LEANANDMEAN
 487   PAssert(IsClass(CISCO_H225_CallSignallingParam::Class()), PInvalidCast);
 488 #endif
 489   return new CISCO_H225_CallSignallingParam(*this);
 490 }
 491
 492
 493 //
 494 // CommonParam
 495 //
 496
 497 CISCO_H225_CommonParam::CISCO_H225_CommonParam(unsigned tag, PASN_Object::TagClass tagClass)
 498   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 499 {
 500 }
 501
 502
 503 #ifndef PASN_NOPRINTON
 504 void CISCO_H225_CommonParam::PrintOn(ostream & strm) const
 505 {
 506   int indent = strm.precision() + 2;
 507   strm << "{\n";
 508   strm << setw(indent+17) << "redirectIEinfo = " << setprecision(indent) << m_redirectIEinfo << '\n';
 509   strm << setw(indent-1) << setprecision(indent-2) << "}";
 510 }
 511 #endif
 512
 513
 514 PObject::Comparison CISCO_H225_CommonParam::Compare(const PObject & obj) const
 515 {
 516 #ifndef PASN_LEANANDMEAN
 517   PAssert(PIsDescendant(&obj, CISCO_H225_CommonParam), PInvalidCast);
 518 #endif
 519   const CISCO_H225_CommonParam & other = (const CISCO_H225_CommonParam &)obj;
 520
 521   Comparison result;
 522
 523   if ((result = m_redirectIEinfo.Compare(other.m_redirectIEinfo)) != EqualTo)
 524     return result;
 525
 526   return PASN_Sequence::Compare(other);
 527 }
 528
 529
 530 PINDEX CISCO_H225_CommonParam::GetDataLength() const
 531 {
 532   PINDEX length = 0;
 533   length += m_redirectIEinfo.GetObjectLength();
 534   return length;
 535 }
 536
 537
 538 BOOL CISCO_H225_CommonParam::Decode(PASN_Stream & strm)
 539 {
 540   if (!PreambleDecode(strm))
 541     return FALSE;
 542
 543   if (!m_redirectIEinfo.Decode(strm))
 544     return FALSE;
 545
 546   return UnknownExtensionsDecode(strm);
 547 }
 548
 549
 550 void CISCO_H225_CommonParam::Encode(PASN_Stream & strm) const
 551 {
 552   PreambleEncode(strm);
 553
 554   m_redirectIEinfo.Encode(strm);
 555
 556   UnknownExtensionsEncode(strm);
 557 }
 558
 559
 560 PObject * CISCO_H225_CommonParam::Clone() const
 561 {
 562 #ifndef PASN_LEANANDMEAN
 563   PAssert(IsClass(CISCO_H225_CommonParam::Class()), PInvalidCast);
 564 #endif
 565   return new CISCO_H225_CommonParam(*this);
 566 }
 567
 568
 569 //
 570 // ProgIndParam
 571 //
 572
 573 CISCO_H225_ProgIndParam::CISCO_H225_ProgIndParam(unsigned tag, PASN_Object::TagClass tagClass)
 574   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 575 {
 576 }
 577
 578
 579 #ifndef PASN_NOPRINTON
 580 void CISCO_H225_ProgIndParam::PrintOn(ostream & strm) const
 581 {
 582   int indent = strm.precision() + 2;
 583   strm << "{\n";
 584   strm << setw(indent+16) << "progIndIEinfo = " << setprecision(indent) << m_progIndIEinfo << '\n';
 585   strm << setw(indent-1) << setprecision(indent-2) << "}";
 586 }
 587 #endif
 588
 589
 590 PObject::Comparison CISCO_H225_ProgIndParam::Compare(const PObject & obj) const
 591 {
 592 #ifndef PASN_LEANANDMEAN
 593   PAssert(PIsDescendant(&obj, CISCO_H225_ProgIndParam), PInvalidCast);
 594 #endif
 595   const CISCO_H225_ProgIndParam & other = (const CISCO_H225_ProgIndParam &)obj;
 596
 597   Comparison result;
 598
 599   if ((result = m_progIndIEinfo.Compare(other.m_progIndIEinfo)) != EqualTo)
 600     return result;
 601
 602   return PASN_Sequence::Compare(other);
 603 }
 604
 605
 606 PINDEX CISCO_H225_ProgIndParam::GetDataLength() const
 607 {
 608   PINDEX length = 0;
 609   length += m_progIndIEinfo.GetObjectLength();
 610   return length;
 611 }
 612
 613
 614 BOOL CISCO_H225_ProgIndParam::Decode(PASN_Stream & strm)
 615 {
 616   if (!PreambleDecode(strm))
 617     return FALSE;
 618
 619   if (!m_progIndIEinfo.Decode(strm))
 620     return FALSE;
 621
 622   return UnknownExtensionsDecode(strm);
 623 }
 624
 625
 626 void CISCO_H225_ProgIndParam::Encode(PASN_Stream & strm) const
 627 {
 628   PreambleEncode(strm);
 629
 630   m_progIndIEinfo.Encode(strm);
 631
 632   UnknownExtensionsEncode(strm);
 633 }
 634
 635
 636 PObject * CISCO_H225_ProgIndParam::Clone() const
 637 {
 638 #ifndef PASN_LEANANDMEAN
 639   PAssert(IsClass(CISCO_H225_ProgIndParam::Class()), PInvalidCast);
 640 #endif
 641   return new CISCO_H225_ProgIndParam(*this);
 642 }
 643
 644
 645 //
 646 // ProtoParam
 647 //
 648
 649 CISCO_H225_ProtoParam::CISCO_H225_ProtoParam(unsigned tag, PASN_Object::TagClass tagClass)
 650   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 651 {
 652 }
 653
 654
 655 #ifndef PASN_NOPRINTON
 656 void CISCO_H225_ProtoParam::PrintOn(ostream & strm) const
 657 {
 658   int indent = strm.precision() + 2;
 659   strm << "{\n";
 660   strm << setw(indent+17) << "qsigNonStdInfo = " << setprecision(indent) << m_qsigNonStdInfo << '\n';
 661   strm << setw(indent-1) << setprecision(indent-2) << "}";
 662 }
 663 #endif
 664
 665
 666 PObject::Comparison CISCO_H225_ProtoParam::Compare(const PObject & obj) const
 667 {
 668 #ifndef PASN_LEANANDMEAN
 669   PAssert(PIsDescendant(&obj, CISCO_H225_ProtoParam), PInvalidCast);
 670 #endif
 671   const CISCO_H225_ProtoParam & other = (const CISCO_H225_ProtoParam &)obj;
 672
 673   Comparison result;
 674
 675   if ((result = m_qsigNonStdInfo.Compare(other.m_qsigNonStdInfo)) != EqualTo)
 676     return result;
 677
 678   return PASN_Sequence::Compare(other);
 679 }
 680
 681
 682 PINDEX CISCO_H225_ProtoParam::GetDataLength() const
 683 {
 684   PINDEX length = 0;
 685   length += m_qsigNonStdInfo.GetObjectLength();
 686   return length;
 687 }
 688
 689
 690 BOOL CISCO_H225_ProtoParam::Decode(PASN_Stream & strm)
 691 {
 692   if (!PreambleDecode(strm))
 693     return FALSE;
 694
 695   if (!m_qsigNonStdInfo.Decode(strm))
 696     return FALSE;
 697
 698   return UnknownExtensionsDecode(strm);
 699 }
 700
 701
 702 void CISCO_H225_ProtoParam::Encode(PASN_Stream & strm) const
 703 {
 704   PreambleEncode(strm);
 705
 706   m_qsigNonStdInfo.Encode(strm);
 707
 708   UnknownExtensionsEncode(strm);
 709 }
 710
 711
 712 PObject * CISCO_H225_ProtoParam::Clone() const
 713 {
 714 #ifndef PASN_LEANANDMEAN
 715   PAssert(IsClass(CISCO_H225_ProtoParam::Class()), PInvalidCast);
 716 #endif
 717   return new CISCO_H225_ProtoParam(*this);
 718 }
 719
 720
 721 //
 722 // H323_UU_NonStdInfo
 723 //
 724
 725 CISCO_H225_H323_UU_NonStdInfo::CISCO_H225_H323_UU_NonStdInfo(unsigned tag, PASN_Object::TagClass tagClass)
 726   : PASN_Sequence(tag, tagClass, 3, TRUE, 6)
 727 {
 728 }
 729
 730
 731 #ifndef PASN_NOPRINTON
 732 void CISCO_H225_H323_UU_NonStdInfo::PrintOn(ostream & strm) const
 733 {
 734   int indent = strm.precision() + 2;
 735   strm << "{\n";
 736   if (HasOptionalField(e_version))
 737     strm << setw(indent+10) << "version = " << setprecision(indent) << m_version << '\n';
 738   if (HasOptionalField(e_protoParam))
 739     strm << setw(indent+13) << "protoParam = " << setprecision(indent) << m_protoParam << '\n';
 740   if (HasOptionalField(e_commonParam))
 741     strm << setw(indent+14) << "commonParam = " << setprecision(indent) << m_commonParam << '\n';
 742   if (HasOptionalField(e_dummy1))
 743     strm << setw(indent+9) << "dummy1 = " << setprecision(indent) << m_dummy1 << '\n';
 744   if (HasOptionalField(e_progIndParam))
 745     strm << setw(indent+15) << "progIndParam = " << setprecision(indent) << m_progIndParam << '\n';
 746   if (HasOptionalField(e_callMgrParam))
 747     strm << setw(indent+15) << "callMgrParam = " << setprecision(indent) << m_callMgrParam << '\n';
 748   if (HasOptionalField(e_callSignallingParam))
 749     strm << setw(indent+22) << "callSignallingParam = " << setprecision(indent) << m_callSignallingParam << '\n';
 750   if (HasOptionalField(e_dummy2))
 751     strm << setw(indent+9) << "dummy2 = " << setprecision(indent) << m_dummy2 << '\n';
 752   if (HasOptionalField(e_callPreserveParam))
 753     strm << setw(indent+20) << "callPreserveParam = " << setprecision(indent) << m_callPreserveParam << '\n';
 754   strm << setw(indent-1) << setprecision(indent-2) << "}";
 755 }
 756 #endif
 757
 758
 759 PObject::Comparison CISCO_H225_H323_UU_NonStdInfo::Compare(const PObject & obj) const
 760 {
 761 #ifndef PASN_LEANANDMEAN
 762   PAssert(PIsDescendant(&obj, CISCO_H225_H323_UU_NonStdInfo), PInvalidCast);
 763 #endif
 764   const CISCO_H225_H323_UU_NonStdInfo & other = (const CISCO_H225_H323_UU_NonStdInfo &)obj;
 765
 766   Comparison result;
 767
 768   if ((result = m_version.Compare(other.m_version)) != EqualTo)
 769     return result;
 770   if ((result = m_protoParam.Compare(other.m_protoParam)) != EqualTo)
 771     return result;
 772   if ((result = m_commonParam.Compare(other.m_commonParam)) != EqualTo)
 773     return result;
 774
 775   return PASN_Sequence::Compare(other);
 776 }
 777
 778
 779 PINDEX CISCO_H225_H323_UU_NonStdInfo::GetDataLength() const
 780 {
 781   PINDEX length = 0;
 782   if (HasOptionalField(e_version))
 783     length += m_version.GetObjectLength();
 784   if (HasOptionalField(e_protoParam))
 785     length += m_protoParam.GetObjectLength();
 786   if (HasOptionalField(e_commonParam))
 787     length += m_commonParam.GetObjectLength();
 788   return length;
 789 }
 790
 791
 792 BOOL CISCO_H225_H323_UU_NonStdInfo::Decode(PASN_Stream & strm)
 793 {
 794   if (!PreambleDecode(strm))
 795     return FALSE;
 796
 797   if (HasOptionalField(e_version) && !m_version.Decode(strm))
 798     return FALSE;
 799   if (HasOptionalField(e_protoParam) && !m_protoParam.Decode(strm))
 800     return FALSE;
 801   if (HasOptionalField(e_commonParam) && !m_commonParam.Decode(strm))
 802     return FALSE;
 803   if (!KnownExtensionDecode(strm, e_dummy1, m_dummy1))
 804     return FALSE;
 805   if (!KnownExtensionDecode(strm, e_progIndParam, m_progIndParam))
 806     return FALSE;
 807   if (!KnownExtensionDecode(strm, e_callMgrParam, m_callMgrParam))
 808     return FALSE;
 809   if (!KnownExtensionDecode(strm, e_callSignallingParam, m_callSignallingParam))
 810     return FALSE;
 811   if (!KnownExtensionDecode(strm, e_dummy2, m_dummy2))
 812     return FALSE;
 813   if (!KnownExtensionDecode(strm, e_callPreserveParam, m_callPreserveParam))
 814     return FALSE;
 815
 816   return UnknownExtensionsDecode(strm);
 817 }
 818
 819
 820 void CISCO_H225_H323_UU_NonStdInfo::Encode(PASN_Stream & strm) const
 821 {
 822   PreambleEncode(strm);
 823
 824   if (HasOptionalField(e_version))
 825     m_version.Encode(strm);
 826   if (HasOptionalField(e_protoParam))
 827     m_protoParam.Encode(strm);
 828   if (HasOptionalField(e_commonParam))
 829     m_commonParam.Encode(strm);
 830   KnownExtensionEncode(strm, e_dummy1, m_dummy1);
 831   KnownExtensionEncode(strm, e_progIndParam, m_progIndParam);
 832   KnownExtensionEncode(strm, e_callMgrParam, m_callMgrParam);
 833   KnownExtensionEncode(strm, e_callSignallingParam, m_callSignallingParam);
 834   KnownExtensionEncode(strm, e_dummy2, m_dummy2);
 835   KnownExtensionEncode(strm, e_callPreserveParam, m_callPreserveParam);
 836
 837   UnknownExtensionsEncode(strm);
 838 }
 839
 840
 841 PObject * CISCO_H225_H323_UU_NonStdInfo::Clone() const
 842 {
 843 #ifndef PASN_LEANANDMEAN
 844   PAssert(IsClass(CISCO_H225_H323_UU_NonStdInfo::Class()), PInvalidCast);
 845 #endif
 846   return new CISCO_H225_H323_UU_NonStdInfo(*this);
 847 }
 848
 849
 850 #endif // if ! H323_DISABLE_CISCO_H225
 851
 852
 853 // End of cisco-h225.cxx