lib/libopenh323/src/h4509.cxx

   1 //
   2 // h4509.cxx
   3 //
   4 // Code automatically generated by asnparse.
   5 //
   6
   7 #ifdef P_USE_PRAGMA
   8 #pragma implementation "h4509.h"
   9 #endif
  10
  11 #include <ptlib.h>
  12 #include "h4509.h"
  13
  14 #define new PNEW
  15
  16
  17 #if ! H323_DISABLE_H4509
  18
  19
  20
  21 #ifndef PASN_NOPRINTON
  22 const static PASN_Names Names_H4509_H323CallCompletionOperations[]={
  23         {"ccbsRequest",40}
  24        ,{"ccnrRequest",27}
  25        ,{"ccCancel",28}
  26        ,{"ccExecPossible",29}
  27        ,{"ccRingout",31}
  28        ,{"ccSuspend",32}
  29        ,{"ccResume",33}
  30 };
  31 #endif
  32 //
  33 // H323CallCompletionOperations
  34 //
  35
  36 H4509_H323CallCompletionOperations::H4509_H323CallCompletionOperations(unsigned tag, PASN_Object::TagClass tagClass)
  37   : PASN_Enumeration(tag, tagClass, 40, FALSE
  38 #ifndef PASN_NOPRINTON
  39     ,(const PASN_Names *)Names_H4509_H323CallCompletionOperations,7
  40 #endif
  41     )
  42 {
  43 }
  44
  45
  46 H4509_H323CallCompletionOperations & H4509_H323CallCompletionOperations::operator=(unsigned v)
  47 {
  48   SetValue(v);
  49   return *this;
  50 }
  51
  52
  53 PObject * H4509_H323CallCompletionOperations::Clone() const
  54 {
  55 #ifndef PASN_LEANANDMEAN
  56   PAssert(IsClass(H4509_H323CallCompletionOperations::Class()), PInvalidCast);
  57 #endif
  58   return new H4509_H323CallCompletionOperations(*this);
  59 }
  60
  61
  62
  63 #ifndef PASN_NOPRINTON
  64 const static PASN_Names Names_H4509_CcArg[]={
  65       {"shortArg",0}
  66      ,{"longArg",1}
  67 };
  68 #endif
  69 //
  70 // CcArg
  71 //
  72
  73 H4509_CcArg::H4509_CcArg(unsigned tag, PASN_Object::TagClass tagClass)
  74   : PASN_Choice(tag, tagClass, 2, TRUE
  75 #ifndef PASN_NOPRINTON
  76     ,(const PASN_Names *)Names_H4509_CcArg,2
  77 #endif
  78 )
  79 {
  80 }
  81
  82
  83 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  84 H4509_CcArg::operator H4509_CcShortArg &() const
  85 #else
  86 H4509_CcArg::operator H4509_CcShortArg &()
  87 {
  88 #ifndef PASN_LEANANDMEAN
  89   PAssert(PIsDescendant(PAssertNULL(choice), H4509_CcShortArg), PInvalidCast);
  90 #endif
  91   return *(H4509_CcShortArg *)choice;
  92 }
  93
  94
  95 H4509_CcArg::operator const H4509_CcShortArg &() const
  96 #endif
  97 {
  98 #ifndef PASN_LEANANDMEAN
  99   PAssert(PIsDescendant(PAssertNULL(choice), H4509_CcShortArg), PInvalidCast);
 100 #endif
 101   return *(H4509_CcShortArg *)choice;
 102 }
 103
 104
 105 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 106 H4509_CcArg::operator H4509_CcLongArg &() const
 107 #else
 108 H4509_CcArg::operator H4509_CcLongArg &()
 109 {
 110 #ifndef PASN_LEANANDMEAN
 111   PAssert(PIsDescendant(PAssertNULL(choice), H4509_CcLongArg), PInvalidCast);
 112 #endif
 113   return *(H4509_CcLongArg *)choice;
 114 }
 115
 116
 117 H4509_CcArg::operator const H4509_CcLongArg &() const
 118 #endif
 119 {
 120 #ifndef PASN_LEANANDMEAN
 121   PAssert(PIsDescendant(PAssertNULL(choice), H4509_CcLongArg), PInvalidCast);
 122 #endif
 123   return *(H4509_CcLongArg *)choice;
 124 }
 125
 126
 127 BOOL H4509_CcArg::CreateObject()
 128 {
 129   switch (tag) {
 130     case e_shortArg :
 131       choice = new H4509_CcShortArg();
 132       return TRUE;
 133     case e_longArg :
 134       choice = new H4509_CcLongArg();
 135       return TRUE;
 136   }
 137
 138   choice = NULL;
 139   return FALSE;
 140 }
 141
 142
 143 PObject * H4509_CcArg::Clone() const
 144 {
 145 #ifndef PASN_LEANANDMEAN
 146   PAssert(IsClass(H4509_CcArg::Class()), PInvalidCast);
 147 #endif
 148   return new H4509_CcArg(*this);
 149 }
 150
 151
 152 #ifndef PASN_NOPRINTON
 153 const static PASN_Names Names_H4509_CallCompletionErrors[]={
 154         {"shortTermRejection",1010}
 155        ,{"longTermRejection",1011}
 156        ,{"remoteUserBusyAgain",1012}
 157        ,{"failureToMatch",1013}
 158 };
 159 #endif
 160 //
 161 // CallCompletionErrors
 162 //
 163
 164 H4509_CallCompletionErrors::H4509_CallCompletionErrors(unsigned tag, PASN_Object::TagClass tagClass)
 165   : PASN_Enumeration(tag, tagClass, 1013, FALSE
 166 #ifndef PASN_NOPRINTON
 167     ,(const PASN_Names *)Names_H4509_CallCompletionErrors,4
 168 #endif
 169     )
 170 {
 171 }
 172
 173
 174 H4509_CallCompletionErrors & H4509_CallCompletionErrors::operator=(unsigned v)
 175 {
 176   SetValue(v);
 177   return *this;
 178 }
 179
 180
 181 PObject * H4509_CallCompletionErrors::Clone() const
 182 {
 183 #ifndef PASN_LEANANDMEAN
 184   PAssert(IsClass(H4509_CallCompletionErrors::Class()), PInvalidCast);
 185 #endif
 186   return new H4509_CallCompletionErrors(*this);
 187 }
 188
 189
 190 //
 191 // ArrayOf_MixedExtension
 192 //
 193
 194 H4509_ArrayOf_MixedExtension::H4509_ArrayOf_MixedExtension(unsigned tag, PASN_Object::TagClass tagClass)
 195   : PASN_Array(tag, tagClass)
 196 {
 197 }
 198
 199
 200 PASN_Object * H4509_ArrayOf_MixedExtension::CreateObject() const
 201 {
 202   return new H4504_MixedExtension;
 203 }
 204
 205
 206 H4504_MixedExtension & H4509_ArrayOf_MixedExtension::operator[](PINDEX i) const
 207 {
 208   return (H4504_MixedExtension &)array[i];
 209 }
 210
 211
 212 PObject * H4509_ArrayOf_MixedExtension::Clone() const
 213 {
 214 #ifndef PASN_LEANANDMEAN
 215   PAssert(IsClass(H4509_ArrayOf_MixedExtension::Class()), PInvalidCast);
 216 #endif
 217   return new H4509_ArrayOf_MixedExtension(*this);
 218 }
 219
 220
 221 //
 222 // CcRequestArg
 223 //
 224
 225 H4509_CcRequestArg::H4509_CcRequestArg(unsigned tag, PASN_Object::TagClass tagClass)
 226   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
 227 {
 228   m_extension.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
 229 }
 230
 231
 232 #ifndef PASN_NOPRINTON
 233 void H4509_CcRequestArg::PrintOn(ostream & strm) const
 234 {
 235   int indent = strm.precision() + 2;
 236   strm << "{\n";
 237   strm << setw(indent+10) << "numberA = " << setprecision(indent) << m_numberA << '\n';
 238   strm << setw(indent+10) << "numberB = " << setprecision(indent) << m_numberB << '\n';
 239   if (HasOptionalField(e_ccIdentifier))
 240     strm << setw(indent+15) << "ccIdentifier = " << setprecision(indent) << m_ccIdentifier << '\n';
 241   strm << setw(indent+10) << "service = " << setprecision(indent) << m_service << '\n';
 242   strm << setw(indent+21) << "can_retain_service = " << setprecision(indent) << m_can_retain_service << '\n';
 243   if (HasOptionalField(e_retain_sig_connection))
 244     strm << setw(indent+24) << "retain_sig_connection = " << setprecision(indent) << m_retain_sig_connection << '\n';
 245   if (HasOptionalField(e_extension))
 246     strm << setw(indent+12) << "extension = " << setprecision(indent) << m_extension << '\n';
 247   strm << setw(indent-1) << setprecision(indent-2) << "}";
 248 }
 249 #endif
 250
 251
 252 PObject::Comparison H4509_CcRequestArg::Compare(const PObject & obj) const
 253 {
 254 #ifndef PASN_LEANANDMEAN
 255   PAssert(PIsDescendant(&obj, H4509_CcRequestArg), PInvalidCast);
 256 #endif
 257   const H4509_CcRequestArg & other = (const H4509_CcRequestArg &)obj;
 258
 259   Comparison result;
 260
 261   if ((result = m_numberA.Compare(other.m_numberA)) != EqualTo)
 262     return result;
 263   if ((result = m_numberB.Compare(other.m_numberB)) != EqualTo)
 264     return result;
 265   if ((result = m_ccIdentifier.Compare(other.m_ccIdentifier)) != EqualTo)
 266     return result;
 267   if ((result = m_service.Compare(other.m_service)) != EqualTo)
 268     return result;
 269   if ((result = m_can_retain_service.Compare(other.m_can_retain_service)) != EqualTo)
 270     return result;
 271   if ((result = m_retain_sig_connection.Compare(other.m_retain_sig_connection)) != EqualTo)
 272     return result;
 273   if ((result = m_extension.Compare(other.m_extension)) != EqualTo)
 274     return result;
 275
 276   return PASN_Sequence::Compare(other);
 277 }
 278
 279
 280 PINDEX H4509_CcRequestArg::GetDataLength() const
 281 {
 282   PINDEX length = 0;
 283   length += m_numberA.GetObjectLength();
 284   length += m_numberB.GetObjectLength();
 285   if (HasOptionalField(e_ccIdentifier))
 286     length += m_ccIdentifier.GetObjectLength();
 287   length += m_service.GetObjectLength();
 288   length += m_can_retain_service.GetObjectLength();
 289   if (HasOptionalField(e_retain_sig_connection))
 290     length += m_retain_sig_connection.GetObjectLength();
 291   if (HasOptionalField(e_extension))
 292     length += m_extension.GetObjectLength();
 293   return length;
 294 }
 295
 296
 297 BOOL H4509_CcRequestArg::Decode(PASN_Stream & strm)
 298 {
 299   if (!PreambleDecode(strm))
 300     return FALSE;
 301
 302   if (!m_numberA.Decode(strm))
 303     return FALSE;
 304   if (!m_numberB.Decode(strm))
 305     return FALSE;
 306   if (HasOptionalField(e_ccIdentifier) && !m_ccIdentifier.Decode(strm))
 307     return FALSE;
 308   if (!m_service.Decode(strm))
 309     return FALSE;
 310   if (!m_can_retain_service.Decode(strm))
 311     return FALSE;
 312   if (HasOptionalField(e_retain_sig_connection) && !m_retain_sig_connection.Decode(strm))
 313     return FALSE;
 314   if (HasOptionalField(e_extension) && !m_extension.Decode(strm))
 315     return FALSE;
 316
 317   return UnknownExtensionsDecode(strm);
 318 }
 319
 320
 321 void H4509_CcRequestArg::Encode(PASN_Stream & strm) const
 322 {
 323   PreambleEncode(strm);
 324
 325   m_numberA.Encode(strm);
 326   m_numberB.Encode(strm);
 327   if (HasOptionalField(e_ccIdentifier))
 328     m_ccIdentifier.Encode(strm);
 329   m_service.Encode(strm);
 330   m_can_retain_service.Encode(strm);
 331   if (HasOptionalField(e_retain_sig_connection))
 332     m_retain_sig_connection.Encode(strm);
 333   if (HasOptionalField(e_extension))
 334     m_extension.Encode(strm);
 335
 336   UnknownExtensionsEncode(strm);
 337 }
 338
 339
 340 PObject * H4509_CcRequestArg::Clone() const
 341 {
 342 #ifndef PASN_LEANANDMEAN
 343   PAssert(IsClass(H4509_CcRequestArg::Class()), PInvalidCast);
 344 #endif
 345   return new H4509_CcRequestArg(*this);
 346 }
 347
 348
 349 //
 350 // CcRequestRes
 351 //
 352
 353 H4509_CcRequestRes::H4509_CcRequestRes(unsigned tag, PASN_Object::TagClass tagClass)
 354   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
 355 {
 356   m_extension.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
 357 }
 358
 359
 360 #ifndef PASN_NOPRINTON
 361 void H4509_CcRequestRes::PrintOn(ostream & strm) const
 362 {
 363   int indent = strm.precision() + 2;
 364   strm << "{\n";
 365   strm << setw(indent+17) << "retain_service = " << setprecision(indent) << m_retain_service << '\n';
 366   if (HasOptionalField(e_extension))
 367     strm << setw(indent+12) << "extension = " << setprecision(indent) << m_extension << '\n';
 368   strm << setw(indent-1) << setprecision(indent-2) << "}";
 369 }
 370 #endif
 371
 372
 373 PObject::Comparison H4509_CcRequestRes::Compare(const PObject & obj) const
 374 {
 375 #ifndef PASN_LEANANDMEAN
 376   PAssert(PIsDescendant(&obj, H4509_CcRequestRes), PInvalidCast);
 377 #endif
 378   const H4509_CcRequestRes & other = (const H4509_CcRequestRes &)obj;
 379
 380   Comparison result;
 381
 382   if ((result = m_retain_service.Compare(other.m_retain_service)) != EqualTo)
 383     return result;
 384   if ((result = m_extension.Compare(other.m_extension)) != EqualTo)
 385     return result;
 386
 387   return PASN_Sequence::Compare(other);
 388 }
 389
 390
 391 PINDEX H4509_CcRequestRes::GetDataLength() const
 392 {
 393   PINDEX length = 0;
 394   length += m_retain_service.GetObjectLength();
 395   if (HasOptionalField(e_extension))
 396     length += m_extension.GetObjectLength();
 397   return length;
 398 }
 399
 400
 401 BOOL H4509_CcRequestRes::Decode(PASN_Stream & strm)
 402 {
 403   if (!PreambleDecode(strm))
 404     return FALSE;
 405
 406   if (!m_retain_service.Decode(strm))
 407     return FALSE;
 408   if (HasOptionalField(e_extension) && !m_extension.Decode(strm))
 409     return FALSE;
 410
 411   return UnknownExtensionsDecode(strm);
 412 }
 413
 414
 415 void H4509_CcRequestRes::Encode(PASN_Stream & strm) const
 416 {
 417   PreambleEncode(strm);
 418
 419   m_retain_service.Encode(strm);
 420   if (HasOptionalField(e_extension))
 421     m_extension.Encode(strm);
 422
 423   UnknownExtensionsEncode(strm);
 424 }
 425
 426
 427 PObject * H4509_CcRequestRes::Clone() const
 428 {
 429 #ifndef PASN_LEANANDMEAN
 430   PAssert(IsClass(H4509_CcRequestRes::Class()), PInvalidCast);
 431 #endif
 432   return new H4509_CcRequestRes(*this);
 433 }
 434
 435
 436 //
 437 // CcShortArg
 438 //
 439
 440 H4509_CcShortArg::H4509_CcShortArg(unsigned tag, PASN_Object::TagClass tagClass)
 441   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
 442 {
 443   m_extension.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
 444 }
 445
 446
 447 #ifndef PASN_NOPRINTON
 448 void H4509_CcShortArg::PrintOn(ostream & strm) const
 449 {
 450   int indent = strm.precision() + 2;
 451   strm << "{\n";
 452   if (HasOptionalField(e_ccIdentifier))
 453     strm << setw(indent+15) << "ccIdentifier = " << setprecision(indent) << m_ccIdentifier << '\n';
 454   if (HasOptionalField(e_extension))
 455     strm << setw(indent+12) << "extension = " << setprecision(indent) << m_extension << '\n';
 456   strm << setw(indent-1) << setprecision(indent-2) << "}";
 457 }
 458 #endif
 459
 460
 461 PObject::Comparison H4509_CcShortArg::Compare(const PObject & obj) const
 462 {
 463 #ifndef PASN_LEANANDMEAN
 464   PAssert(PIsDescendant(&obj, H4509_CcShortArg), PInvalidCast);
 465 #endif
 466   const H4509_CcShortArg & other = (const H4509_CcShortArg &)obj;
 467
 468   Comparison result;
 469
 470   if ((result = m_ccIdentifier.Compare(other.m_ccIdentifier)) != EqualTo)
 471     return result;
 472   if ((result = m_extension.Compare(other.m_extension)) != EqualTo)
 473     return result;
 474
 475   return PASN_Sequence::Compare(other);
 476 }
 477
 478
 479 PINDEX H4509_CcShortArg::GetDataLength() const
 480 {
 481   PINDEX length = 0;
 482   if (HasOptionalField(e_ccIdentifier))
 483     length += m_ccIdentifier.GetObjectLength();
 484   if (HasOptionalField(e_extension))
 485     length += m_extension.GetObjectLength();
 486   return length;
 487 }
 488
 489
 490 BOOL H4509_CcShortArg::Decode(PASN_Stream & strm)
 491 {
 492   if (!PreambleDecode(strm))
 493     return FALSE;
 494
 495   if (HasOptionalField(e_ccIdentifier) && !m_ccIdentifier.Decode(strm))
 496     return FALSE;
 497   if (HasOptionalField(e_extension) && !m_extension.Decode(strm))
 498     return FALSE;
 499
 500   return UnknownExtensionsDecode(strm);
 501 }
 502
 503
 504 void H4509_CcShortArg::Encode(PASN_Stream & strm) const
 505 {
 506   PreambleEncode(strm);
 507
 508   if (HasOptionalField(e_ccIdentifier))
 509     m_ccIdentifier.Encode(strm);
 510   if (HasOptionalField(e_extension))
 511     m_extension.Encode(strm);
 512
 513   UnknownExtensionsEncode(strm);
 514 }
 515
 516
 517 PObject * H4509_CcShortArg::Clone() const
 518 {
 519 #ifndef PASN_LEANANDMEAN
 520   PAssert(IsClass(H4509_CcShortArg::Class()), PInvalidCast);
 521 #endif
 522   return new H4509_CcShortArg(*this);
 523 }
 524
 525
 526 //
 527 // CcLongArg
 528 //
 529
 530 H4509_CcLongArg::H4509_CcLongArg(unsigned tag, PASN_Object::TagClass tagClass)
 531   : PASN_Sequence(tag, tagClass, 5, TRUE, 0)
 532 {
 533   m_extension.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
 534 }
 535
 536
 537 #ifndef PASN_NOPRINTON
 538 void H4509_CcLongArg::PrintOn(ostream & strm) const
 539 {
 540   int indent = strm.precision() + 2;
 541   strm << "{\n";
 542   if (HasOptionalField(e_numberA))
 543     strm << setw(indent+10) << "numberA = " << setprecision(indent) << m_numberA << '\n';
 544   if (HasOptionalField(e_numberB))
 545     strm << setw(indent+10) << "numberB = " << setprecision(indent) << m_numberB << '\n';
 546   if (HasOptionalField(e_ccIdentifier))
 547     strm << setw(indent+15) << "ccIdentifier = " << setprecision(indent) << m_ccIdentifier << '\n';
 548   if (HasOptionalField(e_service))
 549     strm << setw(indent+10) << "service = " << setprecision(indent) << m_service << '\n';
 550   if (HasOptionalField(e_extension))
 551     strm << setw(indent+12) << "extension = " << setprecision(indent) << m_extension << '\n';
 552   strm << setw(indent-1) << setprecision(indent-2) << "}";
 553 }
 554 #endif
 555
 556
 557 PObject::Comparison H4509_CcLongArg::Compare(const PObject & obj) const
 558 {
 559 #ifndef PASN_LEANANDMEAN
 560   PAssert(PIsDescendant(&obj, H4509_CcLongArg), PInvalidCast);
 561 #endif
 562   const H4509_CcLongArg & other = (const H4509_CcLongArg &)obj;
 563
 564   Comparison result;
 565
 566   if ((result = m_numberA.Compare(other.m_numberA)) != EqualTo)
 567     return result;
 568   if ((result = m_numberB.Compare(other.m_numberB)) != EqualTo)
 569     return result;
 570   if ((result = m_ccIdentifier.Compare(other.m_ccIdentifier)) != EqualTo)
 571     return result;
 572   if ((result = m_service.Compare(other.m_service)) != EqualTo)
 573     return result;
 574   if ((result = m_extension.Compare(other.m_extension)) != EqualTo)
 575     return result;
 576
 577   return PASN_Sequence::Compare(other);
 578 }
 579
 580
 581 PINDEX H4509_CcLongArg::GetDataLength() const
 582 {
 583   PINDEX length = 0;
 584   if (HasOptionalField(e_numberA))
 585     length += m_numberA.GetObjectLength();
 586   if (HasOptionalField(e_numberB))
 587     length += m_numberB.GetObjectLength();
 588   if (HasOptionalField(e_ccIdentifier))
 589     length += m_ccIdentifier.GetObjectLength();
 590   if (HasOptionalField(e_service))
 591     length += m_service.GetObjectLength();
 592   if (HasOptionalField(e_extension))
 593     length += m_extension.GetObjectLength();
 594   return length;
 595 }
 596
 597
 598 BOOL H4509_CcLongArg::Decode(PASN_Stream & strm)
 599 {
 600   if (!PreambleDecode(strm))
 601     return FALSE;
 602
 603   if (HasOptionalField(e_numberA) && !m_numberA.Decode(strm))
 604     return FALSE;
 605   if (HasOptionalField(e_numberB) && !m_numberB.Decode(strm))
 606     return FALSE;
 607   if (HasOptionalField(e_ccIdentifier) && !m_ccIdentifier.Decode(strm))
 608     return FALSE;
 609   if (HasOptionalField(e_service) && !m_service.Decode(strm))
 610     return FALSE;
 611   if (HasOptionalField(e_extension) && !m_extension.Decode(strm))
 612     return FALSE;
 613
 614   return UnknownExtensionsDecode(strm);
 615 }
 616
 617
 618 void H4509_CcLongArg::Encode(PASN_Stream & strm) const
 619 {
 620   PreambleEncode(strm);
 621
 622   if (HasOptionalField(e_numberA))
 623     m_numberA.Encode(strm);
 624   if (HasOptionalField(e_numberB))
 625     m_numberB.Encode(strm);
 626   if (HasOptionalField(e_ccIdentifier))
 627     m_ccIdentifier.Encode(strm);
 628   if (HasOptionalField(e_service))
 629     m_service.Encode(strm);
 630   if (HasOptionalField(e_extension))
 631     m_extension.Encode(strm);
 632
 633   UnknownExtensionsEncode(strm);
 634 }
 635
 636
 637 PObject * H4509_CcLongArg::Clone() const
 638 {
 639 #ifndef PASN_LEANANDMEAN
 640   PAssert(IsClass(H4509_CcLongArg::Class()), PInvalidCast);
 641 #endif
 642   return new H4509_CcLongArg(*this);
 643 }
 644
 645
 646 #endif // if ! H323_DISABLE_H4509
 647
 648
 649 // End of h4509.cxx