src/h4501.cxx

   1 //
   2 // h4501.cxx
   3 //
   4 // Code automatically generated by asnparse.
   5 //
   6
   7 #ifdef P_USE_PRAGMA
   8 #pragma implementation "h4501.h"
   9 #endif
  10
  11 #include <ptlib.h>
  12 #include "h4501.h"
  13
  14 #define new PNEW
  15
  16
  17 #if ! H323_DISABLE_H4501
  18
  19
  20
  21
  22 #ifndef PASN_NOPRINTON
  23 const static PASN_Names Names_H4501_EntityType[]={
  24       {"endpoint",0}
  25      ,{"anyEntity",1}
  26 };
  27 #endif
  28 //
  29 // EntityType
  30 //
  31
  32 H4501_EntityType::H4501_EntityType(unsigned tag, PASN_Object::TagClass tagClass)
  33   : PASN_Choice(tag, tagClass, 2, TRUE
  34 #ifndef PASN_NOPRINTON
  35     ,(const PASN_Names *)Names_H4501_EntityType,2
  36 #endif
  37 )
  38 {
  39 }
  40
  41
  42 BOOL H4501_EntityType::CreateObject()
  43 {
  44   choice = (tag <= e_anyEntity) ? new PASN_Null() : NULL;
  45   return choice != NULL;
  46 }
  47
  48
  49 PObject * H4501_EntityType::Clone() const
  50 {
  51 #ifndef PASN_LEANANDMEAN
  52   PAssert(IsClass(H4501_EntityType::Class()), PInvalidCast);
  53 #endif
  54   return new H4501_EntityType(*this);
  55 }
  56
  57
  58 //
  59 // AddressInformation
  60 //
  61
  62 H4501_AddressInformation::H4501_AddressInformation(unsigned tag, PASN_Object::TagClass tagClass)
  63   : H225_AliasAddress(tag, tagClass)
  64 {
  65 }
  66
  67
  68 PObject * H4501_AddressInformation::Clone() const
  69 {
  70 #ifndef PASN_LEANANDMEAN
  71   PAssert(IsClass(H4501_AddressInformation::Class()), PInvalidCast);
  72 #endif
  73   return new H4501_AddressInformation(*this);
  74 }
  75
  76
  77
  78 #ifndef PASN_NOPRINTON
  79 const static PASN_Names Names_H4501_InterpretationApdu[]={
  80       {"discardAnyUnrecognizedInvokePdu",0}
  81      ,{"clearCallIfAnyInvokePduNotRecognized",1}
  82      ,{"rejectAnyUnrecognizedInvokePdu",2}
  83 };
  84 #endif
  85 //
  86 // InterpretationApdu
  87 //
  88
  89 H4501_InterpretationApdu::H4501_InterpretationApdu(unsigned tag, PASN_Object::TagClass tagClass)
  90   : PASN_Choice(tag, tagClass, 3, TRUE
  91 #ifndef PASN_NOPRINTON
  92     ,(const PASN_Names *)Names_H4501_InterpretationApdu,3
  93 #endif
  94 )
  95 {
  96 }
  97
  98
  99 BOOL H4501_InterpretationApdu::CreateObject()
 100 {
 101   choice = (tag <= e_rejectAnyUnrecognizedInvokePdu) ? new PASN_Null() : NULL;
 102   return choice != NULL;
 103 }
 104
 105
 106 PObject * H4501_InterpretationApdu::Clone() const
 107 {
 108 #ifndef PASN_LEANANDMEAN
 109   PAssert(IsClass(H4501_InterpretationApdu::Class()), PInvalidCast);
 110 #endif
 111   return new H4501_InterpretationApdu(*this);
 112 }
 113
 114
 115
 116 #ifndef PASN_NOPRINTON
 117 const static PASN_Names Names_H4501_ServiceApdus[]={
 118       {"rosApdus",0}
 119 };
 120 #endif
 121 //
 122 // ServiceApdus
 123 //
 124
 125 H4501_ServiceApdus::H4501_ServiceApdus(unsigned tag, PASN_Object::TagClass tagClass)
 126   : PASN_Choice(tag, tagClass, 1, TRUE
 127 #ifndef PASN_NOPRINTON
 128     ,(const PASN_Names *)Names_H4501_ServiceApdus,1
 129 #endif
 130 )
 131 {
 132 }
 133
 134
 135 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 136 H4501_ServiceApdus::operator H4501_ArrayOf_ROS &() const
 137 #else
 138 H4501_ServiceApdus::operator H4501_ArrayOf_ROS &()
 139 {
 140 #ifndef PASN_LEANANDMEAN
 141   PAssert(PIsDescendant(PAssertNULL(choice), H4501_ArrayOf_ROS), PInvalidCast);
 142 #endif
 143   return *(H4501_ArrayOf_ROS *)choice;
 144 }
 145
 146
 147 H4501_ServiceApdus::operator const H4501_ArrayOf_ROS &() const
 148 #endif
 149 {
 150 #ifndef PASN_LEANANDMEAN
 151   PAssert(PIsDescendant(PAssertNULL(choice), H4501_ArrayOf_ROS), PInvalidCast);
 152 #endif
 153   return *(H4501_ArrayOf_ROS *)choice;
 154 }
 155
 156
 157 BOOL H4501_ServiceApdus::CreateObject()
 158 {
 159   switch (tag) {
 160     case e_rosApdus :
 161       choice = new H4501_ArrayOf_ROS();
 162       choice->SetConstraints(PASN_Object::FixedConstraint, 1, MaximumValue);
 163       return TRUE;
 164   }
 165
 166   choice = NULL;
 167   return FALSE;
 168 }
 169
 170
 171 PObject * H4501_ServiceApdus::Clone() const
 172 {
 173 #ifndef PASN_LEANANDMEAN
 174   PAssert(IsClass(H4501_ServiceApdus::Class()), PInvalidCast);
 175 #endif
 176   return new H4501_ServiceApdus(*this);
 177 }
 178
 179
 180 //
 181 // InvokeIdSet
 182 //
 183
 184 H4501_InvokeIdSet::H4501_InvokeIdSet(unsigned tag, PASN_Object::TagClass tagClass)
 185   : PASN_Integer(tag, tagClass)
 186 {
 187 }
 188
 189
 190 H4501_InvokeIdSet & H4501_InvokeIdSet::operator=(int v)
 191 {
 192   SetValue(v);
 193   return *this;
 194 }
 195
 196
 197 H4501_InvokeIdSet & H4501_InvokeIdSet::operator=(unsigned v)
 198 {
 199   SetValue(v);
 200   return *this;
 201 }
 202
 203
 204 PObject * H4501_InvokeIdSet::Clone() const
 205 {
 206 #ifndef PASN_LEANANDMEAN
 207   PAssert(IsClass(H4501_InvokeIdSet::Class()), PInvalidCast);
 208 #endif
 209   return new H4501_InvokeIdSet(*this);
 210 }
 211
 212
 213 //
 214 // InvokeIDs
 215 //
 216
 217 H4501_InvokeIDs::H4501_InvokeIDs(unsigned tag, PASN_Object::TagClass tagClass)
 218   : PASN_Integer(tag, tagClass)
 219 {
 220   SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
 221 }
 222
 223
 224 H4501_InvokeIDs & H4501_InvokeIDs::operator=(int v)
 225 {
 226   SetValue(v);
 227   return *this;
 228 }
 229
 230
 231 H4501_InvokeIDs & H4501_InvokeIDs::operator=(unsigned v)
 232 {
 233   SetValue(v);
 234   return *this;
 235 }
 236
 237
 238 PObject * H4501_InvokeIDs::Clone() const
 239 {
 240 #ifndef PASN_LEANANDMEAN
 241   PAssert(IsClass(H4501_InvokeIDs::Class()), PInvalidCast);
 242 #endif
 243   return new H4501_InvokeIDs(*this);
 244 }
 245
 246
 247
 248 #ifndef PASN_NOPRINTON
 249 const static PASN_Names Names_H4501_PresentedAddressScreened[]={
 250       {"presentationAllowedAddress",0}
 251      ,{"presentationRestricted",1}
 252      ,{"numberNotAvailableDueToInterworking",2}
 253      ,{"presentationRestrictedAddress",3}
 254 };
 255 #endif
 256 //
 257 // PresentedAddressScreened
 258 //
 259
 260 H4501_PresentedAddressScreened::H4501_PresentedAddressScreened(unsigned tag, PASN_Object::TagClass tagClass)
 261   : PASN_Choice(tag, tagClass, 4, TRUE
 262 #ifndef PASN_NOPRINTON
 263     ,(const PASN_Names *)Names_H4501_PresentedAddressScreened,4
 264 #endif
 265 )
 266 {
 267 }
 268
 269
 270 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 271 H4501_PresentedAddressScreened::operator H4501_AddressScreened &() const
 272 #else
 273 H4501_PresentedAddressScreened::operator H4501_AddressScreened &()
 274 {
 275 #ifndef PASN_LEANANDMEAN
 276   PAssert(PIsDescendant(PAssertNULL(choice), H4501_AddressScreened), PInvalidCast);
 277 #endif
 278   return *(H4501_AddressScreened *)choice;
 279 }
 280
 281
 282 H4501_PresentedAddressScreened::operator const H4501_AddressScreened &() const
 283 #endif
 284 {
 285 #ifndef PASN_LEANANDMEAN
 286   PAssert(PIsDescendant(PAssertNULL(choice), H4501_AddressScreened), PInvalidCast);
 287 #endif
 288   return *(H4501_AddressScreened *)choice;
 289 }
 290
 291
 292 BOOL H4501_PresentedAddressScreened::CreateObject()
 293 {
 294   switch (tag) {
 295     case e_presentationAllowedAddress :
 296     case e_presentationRestrictedAddress :
 297       choice = new H4501_AddressScreened();
 298       return TRUE;
 299     case e_presentationRestricted :
 300     case e_numberNotAvailableDueToInterworking :
 301       choice = new PASN_Null();
 302       return TRUE;
 303   }
 304
 305   choice = NULL;
 306   return FALSE;
 307 }
 308
 309
 310 PObject * H4501_PresentedAddressScreened::Clone() const
 311 {
 312 #ifndef PASN_LEANANDMEAN
 313   PAssert(IsClass(H4501_PresentedAddressScreened::Class()), PInvalidCast);
 314 #endif
 315   return new H4501_PresentedAddressScreened(*this);
 316 }
 317
 318
 319
 320 #ifndef PASN_NOPRINTON
 321 const static PASN_Names Names_H4501_PresentedAddressUnscreened[]={
 322       {"presentationAllowedAddress",0}
 323      ,{"presentationRestricted",1}
 324      ,{"numberNotAvailableDueToInterworking",2}
 325      ,{"presentationRestrictedAddress",3}
 326 };
 327 #endif
 328 //
 329 // PresentedAddressUnscreened
 330 //
 331
 332 H4501_PresentedAddressUnscreened::H4501_PresentedAddressUnscreened(unsigned tag, PASN_Object::TagClass tagClass)
 333   : PASN_Choice(tag, tagClass, 4, TRUE
 334 #ifndef PASN_NOPRINTON
 335     ,(const PASN_Names *)Names_H4501_PresentedAddressUnscreened,4
 336 #endif
 337 )
 338 {
 339 }
 340
 341
 342 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 343 H4501_PresentedAddressUnscreened::operator H4501_Address &() const
 344 #else
 345 H4501_PresentedAddressUnscreened::operator H4501_Address &()
 346 {
 347 #ifndef PASN_LEANANDMEAN
 348   PAssert(PIsDescendant(PAssertNULL(choice), H4501_Address), PInvalidCast);
 349 #endif
 350   return *(H4501_Address *)choice;
 351 }
 352
 353
 354 H4501_PresentedAddressUnscreened::operator const H4501_Address &() const
 355 #endif
 356 {
 357 #ifndef PASN_LEANANDMEAN
 358   PAssert(PIsDescendant(PAssertNULL(choice), H4501_Address), PInvalidCast);
 359 #endif
 360   return *(H4501_Address *)choice;
 361 }
 362
 363
 364 BOOL H4501_PresentedAddressUnscreened::CreateObject()
 365 {
 366   switch (tag) {
 367     case e_presentationAllowedAddress :
 368     case e_presentationRestrictedAddress :
 369       choice = new H4501_Address();
 370       return TRUE;
 371     case e_presentationRestricted :
 372     case e_numberNotAvailableDueToInterworking :
 373       choice = new PASN_Null();
 374       return TRUE;
 375   }
 376
 377   choice = NULL;
 378   return FALSE;
 379 }
 380
 381
 382 PObject * H4501_PresentedAddressUnscreened::Clone() const
 383 {
 384 #ifndef PASN_LEANANDMEAN
 385   PAssert(IsClass(H4501_PresentedAddressUnscreened::Class()), PInvalidCast);
 386 #endif
 387   return new H4501_PresentedAddressUnscreened(*this);
 388 }
 389
 390
 391
 392 #ifndef PASN_NOPRINTON
 393 const static PASN_Names Names_H4501_PresentedNumberScreened[]={
 394       {"presentationAllowedAddress",0}
 395      ,{"presentationRestricted",1}
 396      ,{"numberNotAvailableDueToInterworking",2}
 397      ,{"presentationRestrictedAddress",3}
 398 };
 399 #endif
 400 //
 401 // PresentedNumberScreened
 402 //
 403
 404 H4501_PresentedNumberScreened::H4501_PresentedNumberScreened(unsigned tag, PASN_Object::TagClass tagClass)
 405   : PASN_Choice(tag, tagClass, 4, TRUE
 406 #ifndef PASN_NOPRINTON
 407     ,(const PASN_Names *)Names_H4501_PresentedNumberScreened,4
 408 #endif
 409 )
 410 {
 411 }
 412
 413
 414 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 415 H4501_PresentedNumberScreened::operator H4501_NumberScreened &() const
 416 #else
 417 H4501_PresentedNumberScreened::operator H4501_NumberScreened &()
 418 {
 419 #ifndef PASN_LEANANDMEAN
 420   PAssert(PIsDescendant(PAssertNULL(choice), H4501_NumberScreened), PInvalidCast);
 421 #endif
 422   return *(H4501_NumberScreened *)choice;
 423 }
 424
 425
 426 H4501_PresentedNumberScreened::operator const H4501_NumberScreened &() const
 427 #endif
 428 {
 429 #ifndef PASN_LEANANDMEAN
 430   PAssert(PIsDescendant(PAssertNULL(choice), H4501_NumberScreened), PInvalidCast);
 431 #endif
 432   return *(H4501_NumberScreened *)choice;
 433 }
 434
 435
 436 BOOL H4501_PresentedNumberScreened::CreateObject()
 437 {
 438   switch (tag) {
 439     case e_presentationAllowedAddress :
 440     case e_presentationRestrictedAddress :
 441       choice = new H4501_NumberScreened();
 442       return TRUE;
 443     case e_presentationRestricted :
 444     case e_numberNotAvailableDueToInterworking :
 445       choice = new PASN_Null();
 446       return TRUE;
 447   }
 448
 449   choice = NULL;
 450   return FALSE;
 451 }
 452
 453
 454 PObject * H4501_PresentedNumberScreened::Clone() const
 455 {
 456 #ifndef PASN_LEANANDMEAN
 457   PAssert(IsClass(H4501_PresentedNumberScreened::Class()), PInvalidCast);
 458 #endif
 459   return new H4501_PresentedNumberScreened(*this);
 460 }
 461
 462
 463
 464 #ifndef PASN_NOPRINTON
 465 const static PASN_Names Names_H4501_PresentedNumberUnscreened[]={
 466       {"presentationAllowedAddress",0}
 467      ,{"presentationRestricted",1}
 468      ,{"numberNotAvailableDueToInterworking",2}
 469      ,{"presentationRestrictedAddress",3}
 470 };
 471 #endif
 472 //
 473 // PresentedNumberUnscreened
 474 //
 475
 476 H4501_PresentedNumberUnscreened::H4501_PresentedNumberUnscreened(unsigned tag, PASN_Object::TagClass tagClass)
 477   : PASN_Choice(tag, tagClass, 4, TRUE
 478 #ifndef PASN_NOPRINTON
 479     ,(const PASN_Names *)Names_H4501_PresentedNumberUnscreened,4
 480 #endif
 481 )
 482 {
 483 }
 484
 485
 486 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 487 H4501_PresentedNumberUnscreened::operator H225_PartyNumber &() const
 488 #else
 489 H4501_PresentedNumberUnscreened::operator H225_PartyNumber &()
 490 {
 491 #ifndef PASN_LEANANDMEAN
 492   PAssert(PIsDescendant(PAssertNULL(choice), H225_PartyNumber), PInvalidCast);
 493 #endif
 494   return *(H225_PartyNumber *)choice;
 495 }
 496
 497
 498 H4501_PresentedNumberUnscreened::operator const H225_PartyNumber &() const
 499 #endif
 500 {
 501 #ifndef PASN_LEANANDMEAN
 502   PAssert(PIsDescendant(PAssertNULL(choice), H225_PartyNumber), PInvalidCast);
 503 #endif
 504   return *(H225_PartyNumber *)choice;
 505 }
 506
 507
 508 BOOL H4501_PresentedNumberUnscreened::CreateObject()
 509 {
 510   switch (tag) {
 511     case e_presentationAllowedAddress :
 512     case e_presentationRestrictedAddress :
 513       choice = new H225_PartyNumber();
 514       return TRUE;
 515     case e_presentationRestricted :
 516     case e_numberNotAvailableDueToInterworking :
 517       choice = new PASN_Null();
 518       return TRUE;
 519   }
 520
 521   choice = NULL;
 522   return FALSE;
 523 }
 524
 525
 526 PObject * H4501_PresentedNumberUnscreened::Clone() const
 527 {
 528 #ifndef PASN_LEANANDMEAN
 529   PAssert(IsClass(H4501_PresentedNumberUnscreened::Class()), PInvalidCast);
 530 #endif
 531   return new H4501_PresentedNumberUnscreened(*this);
 532 }
 533
 534
 535
 536 #ifndef PASN_NOPRINTON
 537 const static PASN_Names Names_H4501_PartySubaddress[]={
 538       {"userSpecifiedSubaddress",0}
 539      ,{"nsapSubaddress",1}
 540 };
 541 #endif
 542 //
 543 // PartySubaddress
 544 //
 545
 546 H4501_PartySubaddress::H4501_PartySubaddress(unsigned tag, PASN_Object::TagClass tagClass)
 547   : PASN_Choice(tag, tagClass, 2, TRUE
 548 #ifndef PASN_NOPRINTON
 549     ,(const PASN_Names *)Names_H4501_PartySubaddress,2
 550 #endif
 551 )
 552 {
 553 }
 554
 555
 556 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 557 H4501_PartySubaddress::operator H4501_UserSpecifiedSubaddress &() const
 558 #else
 559 H4501_PartySubaddress::operator H4501_UserSpecifiedSubaddress &()
 560 {
 561 #ifndef PASN_LEANANDMEAN
 562   PAssert(PIsDescendant(PAssertNULL(choice), H4501_UserSpecifiedSubaddress), PInvalidCast);
 563 #endif
 564   return *(H4501_UserSpecifiedSubaddress *)choice;
 565 }
 566
 567
 568 H4501_PartySubaddress::operator const H4501_UserSpecifiedSubaddress &() const
 569 #endif
 570 {
 571 #ifndef PASN_LEANANDMEAN
 572   PAssert(PIsDescendant(PAssertNULL(choice), H4501_UserSpecifiedSubaddress), PInvalidCast);
 573 #endif
 574   return *(H4501_UserSpecifiedSubaddress *)choice;
 575 }
 576
 577
 578 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 579 H4501_PartySubaddress::operator H4501_NSAPSubaddress &() const
 580 #else
 581 H4501_PartySubaddress::operator H4501_NSAPSubaddress &()
 582 {
 583 #ifndef PASN_LEANANDMEAN
 584   PAssert(PIsDescendant(PAssertNULL(choice), H4501_NSAPSubaddress), PInvalidCast);
 585 #endif
 586   return *(H4501_NSAPSubaddress *)choice;
 587 }
 588
 589
 590 H4501_PartySubaddress::operator const H4501_NSAPSubaddress &() const
 591 #endif
 592 {
 593 #ifndef PASN_LEANANDMEAN
 594   PAssert(PIsDescendant(PAssertNULL(choice), H4501_NSAPSubaddress), PInvalidCast);
 595 #endif
 596   return *(H4501_NSAPSubaddress *)choice;
 597 }
 598
 599
 600 BOOL H4501_PartySubaddress::CreateObject()
 601 {
 602   switch (tag) {
 603     case e_userSpecifiedSubaddress :
 604       choice = new H4501_UserSpecifiedSubaddress();
 605       return TRUE;
 606     case e_nsapSubaddress :
 607       choice = new H4501_NSAPSubaddress();
 608       return TRUE;
 609   }
 610
 611   choice = NULL;
 612   return FALSE;
 613 }
 614
 615
 616 PObject * H4501_PartySubaddress::Clone() const
 617 {
 618 #ifndef PASN_LEANANDMEAN
 619   PAssert(IsClass(H4501_PartySubaddress::Class()), PInvalidCast);
 620 #endif
 621   return new H4501_PartySubaddress(*this);
 622 }
 623
 624
 625 //
 626 // NSAPSubaddress
 627 //
 628
 629 H4501_NSAPSubaddress::H4501_NSAPSubaddress(unsigned tag, PASN_Object::TagClass tagClass)
 630   : PASN_OctetString(tag, tagClass)
 631 {
 632   SetConstraints(PASN_Object::FixedConstraint, 1, 20);
 633 }
 634
 635
 636 H4501_NSAPSubaddress::H4501_NSAPSubaddress(const char * v)
 637 {
 638   SetValue(v);
 639 }
 640
 641
 642 H4501_NSAPSubaddress::H4501_NSAPSubaddress(const PString & v)
 643 {
 644   SetValue(v);
 645 }
 646
 647
 648 H4501_NSAPSubaddress::H4501_NSAPSubaddress(const PBYTEArray & v)
 649 {
 650   SetValue(v);
 651 }
 652
 653
 654 H4501_NSAPSubaddress & H4501_NSAPSubaddress::operator=(const char * v)
 655 {
 656   SetValue(v);
 657   return *this;
 658 }
 659
 660
 661 H4501_NSAPSubaddress & H4501_NSAPSubaddress::operator=(const PString & v)
 662 {
 663   SetValue(v);
 664   return *this;
 665 }
 666
 667
 668 H4501_NSAPSubaddress & H4501_NSAPSubaddress::operator=(const PBYTEArray & v)
 669 {
 670   SetValue(v);
 671   return *this;
 672 }
 673
 674
 675 PObject * H4501_NSAPSubaddress::Clone() const
 676 {
 677 #ifndef PASN_LEANANDMEAN
 678   PAssert(IsClass(H4501_NSAPSubaddress::Class()), PInvalidCast);
 679 #endif
 680   return new H4501_NSAPSubaddress(*this);
 681 }
 682
 683
 684 //
 685 // SubaddressInformation
 686 //
 687
 688 H4501_SubaddressInformation::H4501_SubaddressInformation(unsigned tag, PASN_Object::TagClass tagClass)
 689   : PASN_OctetString(tag, tagClass)
 690 {
 691   SetConstraints(PASN_Object::FixedConstraint, 1, 20);
 692 }
 693
 694
 695 H4501_SubaddressInformation::H4501_SubaddressInformation(const char * v)
 696 {
 697   SetValue(v);
 698 }
 699
 700
 701 H4501_SubaddressInformation::H4501_SubaddressInformation(const PString & v)
 702 {
 703   SetValue(v);
 704 }
 705
 706
 707 H4501_SubaddressInformation::H4501_SubaddressInformation(const PBYTEArray & v)
 708 {
 709   SetValue(v);
 710 }
 711
 712
 713 H4501_SubaddressInformation & H4501_SubaddressInformation::operator=(const char * v)
 714 {
 715   SetValue(v);
 716   return *this;
 717 }
 718
 719
 720 H4501_SubaddressInformation & H4501_SubaddressInformation::operator=(const PString & v)
 721 {
 722   SetValue(v);
 723   return *this;
 724 }
 725
 726
 727 H4501_SubaddressInformation & H4501_SubaddressInformation::operator=(const PBYTEArray & v)
 728 {
 729   SetValue(v);
 730   return *this;
 731 }
 732
 733
 734 PObject * H4501_SubaddressInformation::Clone() const
 735 {
 736 #ifndef PASN_LEANANDMEAN
 737   PAssert(IsClass(H4501_SubaddressInformation::Class()), PInvalidCast);
 738 #endif
 739   return new H4501_SubaddressInformation(*this);
 740 }
 741
 742
 743 #ifndef PASN_NOPRINTON
 744 const static PASN_Names Names_H4501_ScreeningIndicator[]={
 745         {"userProvidedNotScreened",0}
 746        ,{"userProvidedVerifiedAndPassed",1}
 747        ,{"userProvidedVerifiedAndFailed",2}
 748        ,{"networkProvided",3}
 749 };
 750 #endif
 751 //
 752 // ScreeningIndicator
 753 //
 754
 755 H4501_ScreeningIndicator::H4501_ScreeningIndicator(unsigned tag, PASN_Object::TagClass tagClass)
 756   : PASN_Enumeration(tag, tagClass, 3, TRUE
 757 #ifndef PASN_NOPRINTON
 758     ,(const PASN_Names *)Names_H4501_ScreeningIndicator,4
 759 #endif
 760     )
 761 {
 762 }
 763
 764
 765 H4501_ScreeningIndicator & H4501_ScreeningIndicator::operator=(unsigned v)
 766 {
 767   SetValue(v);
 768   return *this;
 769 }
 770
 771
 772 PObject * H4501_ScreeningIndicator::Clone() const
 773 {
 774 #ifndef PASN_LEANANDMEAN
 775   PAssert(IsClass(H4501_ScreeningIndicator::Class()), PInvalidCast);
 776 #endif
 777   return new H4501_ScreeningIndicator(*this);
 778 }
 779
 780
 781 //
 782 // PresentationAllowedIndicator
 783 //
 784
 785 H4501_PresentationAllowedIndicator::H4501_PresentationAllowedIndicator(unsigned tag, PASN_Object::TagClass tagClass)
 786   : PASN_Boolean(tag, tagClass)
 787 {
 788 }
 789
 790
 791 H4501_PresentationAllowedIndicator & H4501_PresentationAllowedIndicator::operator=(BOOL v)
 792 {
 793   SetValue(v);
 794   return *this;
 795 }
 796
 797
 798 PObject * H4501_PresentationAllowedIndicator::Clone() const
 799 {
 800 #ifndef PASN_LEANANDMEAN
 801   PAssert(IsClass(H4501_PresentationAllowedIndicator::Class()), PInvalidCast);
 802 #endif
 803   return new H4501_PresentationAllowedIndicator(*this);
 804 }
 805
 806
 807 #ifndef PASN_NOPRINTON
 808 const static PASN_Names Names_H4501_GeneralErrorList[]={
 809         {"userNotSubscribed",0}
 810        ,{"rejectedByNetwork",1}
 811        ,{"rejectedByUser",2}
 812        ,{"notAvailable",3}
 813        ,{"insufficientInformation",5}
 814        ,{"invalidServedUserNumber",6}
 815        ,{"invalidCallState",7}
 816        ,{"basicServiceNotProvided",8}
 817        ,{"notIncomingCall",9}
 818        ,{"supplementaryServiceInteractionNotAllowed",10}
 819        ,{"resourceUnavailable",11}
 820        ,{"callFailure",25}
 821        ,{"proceduralError",43}
 822 };
 823 #endif
 824 //
 825 // GeneralErrorList
 826 //
 827
 828 H4501_GeneralErrorList::H4501_GeneralErrorList(unsigned tag, PASN_Object::TagClass tagClass)
 829   : PASN_Enumeration(tag, tagClass, 43, FALSE
 830 #ifndef PASN_NOPRINTON
 831     ,(const PASN_Names *)Names_H4501_GeneralErrorList,13
 832 #endif
 833     )
 834 {
 835 }
 836
 837
 838 H4501_GeneralErrorList & H4501_GeneralErrorList::operator=(unsigned v)
 839 {
 840   SetValue(v);
 841   return *this;
 842 }
 843
 844
 845 PObject * H4501_GeneralErrorList::Clone() const
 846 {
 847 #ifndef PASN_LEANANDMEAN
 848   PAssert(IsClass(H4501_GeneralErrorList::Class()), PInvalidCast);
 849 #endif
 850   return new H4501_GeneralErrorList(*this);
 851 }
 852
 853
 854 //
 855 // H225InformationElement
 856 //
 857
 858 H4501_H225InformationElement::H4501_H225InformationElement(unsigned tag, PASN_Object::TagClass tagClass)
 859   : PASN_OctetString(tag, tagClass)
 860 {
 861 }
 862
 863
 864 H4501_H225InformationElement::H4501_H225InformationElement(const char * v)
 865 {
 866   SetValue(v);
 867 }
 868
 869
 870 H4501_H225InformationElement::H4501_H225InformationElement(const PString & v)
 871 {
 872   SetValue(v);
 873 }
 874
 875
 876 H4501_H225InformationElement::H4501_H225InformationElement(const PBYTEArray & v)
 877 {
 878   SetValue(v);
 879 }
 880
 881
 882 H4501_H225InformationElement & H4501_H225InformationElement::operator=(const char * v)
 883 {
 884   SetValue(v);
 885   return *this;
 886 }
 887
 888
 889 H4501_H225InformationElement & H4501_H225InformationElement::operator=(const PString & v)
 890 {
 891   SetValue(v);
 892   return *this;
 893 }
 894
 895
 896 H4501_H225InformationElement & H4501_H225InformationElement::operator=(const PBYTEArray & v)
 897 {
 898   SetValue(v);
 899   return *this;
 900 }
 901
 902
 903 PObject * H4501_H225InformationElement::Clone() const
 904 {
 905 #ifndef PASN_LEANANDMEAN
 906   PAssert(IsClass(H4501_H225InformationElement::Class()), PInvalidCast);
 907 #endif
 908   return new H4501_H225InformationElement(*this);
 909 }
 910
 911
 912 //
 913 // Extension
 914 //
 915
 916 H4501_Extension::H4501_Extension(unsigned tag, PASN_Object::TagClass tagClass)
 917   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
 918 {
 919 }
 920
 921
 922 #ifndef PASN_NOPRINTON
 923 void H4501_Extension::PrintOn(ostream & strm) const
 924 {
 925   int indent = strm.precision() + 2;
 926   strm << "{\n";
 927   strm << setw(indent+14) << "extensionId = " << setprecision(indent) << m_extensionId << '\n';
 928   strm << setw(indent+20) << "extensionArgument = " << setprecision(indent) << m_extensionArgument << '\n';
 929   strm << setw(indent-1) << setprecision(indent-2) << "}";
 930 }
 931 #endif
 932
 933
 934 PObject::Comparison H4501_Extension::Compare(const PObject & obj) const
 935 {
 936 #ifndef PASN_LEANANDMEAN
 937   PAssert(PIsDescendant(&obj, H4501_Extension), PInvalidCast);
 938 #endif
 939   const H4501_Extension & other = (const H4501_Extension &)obj;
 940
 941   Comparison result;
 942
 943   if ((result = m_extensionId.Compare(other.m_extensionId)) != EqualTo)
 944     return result;
 945   if ((result = m_extensionArgument.Compare(other.m_extensionArgument)) != EqualTo)
 946     return result;
 947
 948   return PASN_Sequence::Compare(other);
 949 }
 950
 951
 952 PINDEX H4501_Extension::GetDataLength() const
 953 {
 954   PINDEX length = 0;
 955   length += m_extensionId.GetObjectLength();
 956   length += m_extensionArgument.GetObjectLength();
 957   return length;
 958 }
 959
 960
 961 BOOL H4501_Extension::Decode(PASN_Stream & strm)
 962 {
 963   if (!PreambleDecode(strm))
 964     return FALSE;
 965
 966   if (!m_extensionId.Decode(strm))
 967     return FALSE;
 968   if (!m_extensionArgument.Decode(strm))
 969     return FALSE;
 970
 971   return UnknownExtensionsDecode(strm);
 972 }
 973
 974
 975 void H4501_Extension::Encode(PASN_Stream & strm) const
 976 {
 977   PreambleEncode(strm);
 978
 979   m_extensionId.Encode(strm);
 980   m_extensionArgument.Encode(strm);
 981
 982   UnknownExtensionsEncode(strm);
 983 }
 984
 985
 986 PObject * H4501_Extension::Clone() const
 987 {
 988 #ifndef PASN_LEANANDMEAN
 989   PAssert(IsClass(H4501_Extension::Class()), PInvalidCast);
 990 #endif
 991   return new H4501_Extension(*this);
 992 }
 993
 994
 995 //
 996 // ArrayOf_ROS
 997 //
 998
 999 H4501_ArrayOf_ROS::H4501_ArrayOf_ROS(unsigned tag, PASN_Object::TagClass tagClass)
1000   : PASN_Array(tag, tagClass)
1001 {
1002 }
1003
1004
1005 PASN_Object * H4501_ArrayOf_ROS::CreateObject() const
1006 {
1007   return new X880_ROS;
1008 }
1009
1010
1011 X880_ROS & H4501_ArrayOf_ROS::operator[](PINDEX i) const
1012 {
1013   return (X880_ROS &)array[i];
1014 }
1015
1016
1017 PObject * H4501_ArrayOf_ROS::Clone() const
1018 {
1019 #ifndef PASN_LEANANDMEAN
1020   PAssert(IsClass(H4501_ArrayOf_ROS::Class()), PInvalidCast);
1021 #endif
1022   return new H4501_ArrayOf_ROS(*this);
1023 }
1024
1025
1026 //
1027 // ArrayOf_AliasAddress
1028 //
1029
1030 H4501_ArrayOf_AliasAddress::H4501_ArrayOf_AliasAddress(unsigned tag, PASN_Object::TagClass tagClass)
1031   : PASN_Array(tag, tagClass)
1032 {
1033 }
1034
1035
1036 PASN_Object * H4501_ArrayOf_AliasAddress::CreateObject() const
1037 {
1038   return new H225_AliasAddress;
1039 }
1040
1041
1042 H225_AliasAddress & H4501_ArrayOf_AliasAddress::operator[](PINDEX i) const
1043 {
1044   return (H225_AliasAddress &)array[i];
1045 }
1046
1047
1048 PObject * H4501_ArrayOf_AliasAddress::Clone() const
1049 {
1050 #ifndef PASN_LEANANDMEAN
1051   PAssert(IsClass(H4501_ArrayOf_AliasAddress::Class()), PInvalidCast);
1052 #endif
1053   return new H4501_ArrayOf_AliasAddress(*this);
1054 }
1055
1056
1057 //
1058 // NetworkFacilityExtension
1059 //
1060
1061 H4501_NetworkFacilityExtension::H4501_NetworkFacilityExtension(unsigned tag, PASN_Object::TagClass tagClass)
1062   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
1063 {
1064 }
1065
1066
1067 #ifndef PASN_NOPRINTON
1068 void H4501_NetworkFacilityExtension::PrintOn(ostream & strm) const
1069 {
1070   int indent = strm.precision() + 2;
1071   strm << "{\n";
1072   strm << setw(indent+15) << "sourceEntity = " << setprecision(indent) << m_sourceEntity << '\n';
1073   if (HasOptionalField(e_sourceEntityAddress))
1074     strm << setw(indent+22) << "sourceEntityAddress = " << setprecision(indent) << m_sourceEntityAddress << '\n';
1075   strm << setw(indent+20) << "destinationEntity = " << setprecision(indent) << m_destinationEntity << '\n';
1076   if (HasOptionalField(e_destinationEntityAddress))
1077     strm << setw(indent+27) << "destinationEntityAddress = " << setprecision(indent) << m_destinationEntityAddress << '\n';
1078   strm << setw(indent-1) << setprecision(indent-2) << "}";
1079 }
1080 #endif
1081
1082
1083 PObject::Comparison H4501_NetworkFacilityExtension::Compare(const PObject & obj) const
1084 {
1085 #ifndef PASN_LEANANDMEAN
1086   PAssert(PIsDescendant(&obj, H4501_NetworkFacilityExtension), PInvalidCast);
1087 #endif
1088   const H4501_NetworkFacilityExtension & other = (const H4501_NetworkFacilityExtension &)obj;
1089
1090   Comparison result;
1091
1092   if ((result = m_sourceEntity.Compare(other.m_sourceEntity)) != EqualTo)
1093     return result;
1094   if ((result = m_sourceEntityAddress.Compare(other.m_sourceEntityAddress)) != EqualTo)
1095     return result;
1096   if ((result = m_destinationEntity.Compare(other.m_destinationEntity)) != EqualTo)
1097     return result;
1098   if ((result = m_destinationEntityAddress.Compare(other.m_destinationEntityAddress)) != EqualTo)
1099     return result;
1100
1101   return PASN_Sequence::Compare(other);
1102 }
1103
1104
1105 PINDEX H4501_NetworkFacilityExtension::GetDataLength() const
1106 {
1107   PINDEX length = 0;
1108   length += m_sourceEntity.GetObjectLength();
1109   if (HasOptionalField(e_sourceEntityAddress))
1110     length += m_sourceEntityAddress.GetObjectLength();
1111   length += m_destinationEntity.GetObjectLength();
1112   if (HasOptionalField(e_destinationEntityAddress))
1113     length += m_destinationEntityAddress.GetObjectLength();
1114   return length;
1115 }
1116
1117
1118 BOOL H4501_NetworkFacilityExtension::Decode(PASN_Stream & strm)
1119 {
1120   if (!PreambleDecode(strm))
1121     return FALSE;
1122
1123   if (!m_sourceEntity.Decode(strm))
1124     return FALSE;
1125   if (HasOptionalField(e_sourceEntityAddress) && !m_sourceEntityAddress.Decode(strm))
1126     return FALSE;
1127   if (!m_destinationEntity.Decode(strm))
1128     return FALSE;
1129   if (HasOptionalField(e_destinationEntityAddress) && !m_destinationEntityAddress.Decode(strm))
1130     return FALSE;
1131
1132   return UnknownExtensionsDecode(strm);
1133 }
1134
1135
1136 void H4501_NetworkFacilityExtension::Encode(PASN_Stream & strm) const
1137 {
1138   PreambleEncode(strm);
1139
1140   m_sourceEntity.Encode(strm);
1141   if (HasOptionalField(e_sourceEntityAddress))
1142     m_sourceEntityAddress.Encode(strm);
1143   m_destinationEntity.Encode(strm);
1144   if (HasOptionalField(e_destinationEntityAddress))
1145     m_destinationEntityAddress.Encode(strm);
1146
1147   UnknownExtensionsEncode(strm);
1148 }
1149
1150
1151 PObject * H4501_NetworkFacilityExtension::Clone() const
1152 {
1153 #ifndef PASN_LEANANDMEAN
1154   PAssert(IsClass(H4501_NetworkFacilityExtension::Class()), PInvalidCast);
1155 #endif
1156   return new H4501_NetworkFacilityExtension(*this);
1157 }
1158
1159
1160 //
1161 // AddressScreened
1162 //
1163
1164 H4501_AddressScreened::H4501_AddressScreened(unsigned tag, PASN_Object::TagClass tagClass)
1165   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
1166 {
1167 }
1168
1169
1170 #ifndef PASN_NOPRINTON
1171 void H4501_AddressScreened::PrintOn(ostream & strm) const
1172 {
1173   int indent = strm.precision() + 2;
1174   strm << "{\n";
1175   strm << setw(indent+14) << "partyNumber = " << setprecision(indent) << m_partyNumber << '\n';
1176   strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
1177   if (HasOptionalField(e_partySubaddress))
1178     strm << setw(indent+18) << "partySubaddress = " << setprecision(indent) << m_partySubaddress << '\n';
1179   strm << setw(indent-1) << setprecision(indent-2) << "}";
1180 }
1181 #endif
1182
1183
1184 PObject::Comparison H4501_AddressScreened::Compare(const PObject & obj) const
1185 {
1186 #ifndef PASN_LEANANDMEAN
1187   PAssert(PIsDescendant(&obj, H4501_AddressScreened), PInvalidCast);
1188 #endif
1189   const H4501_AddressScreened & other = (const H4501_AddressScreened &)obj;
1190
1191   Comparison result;
1192
1193   if ((result = m_partyNumber.Compare(other.m_partyNumber)) != EqualTo)
1194     return result;
1195   if ((result = m_screeningIndicator.Compare(other.m_screeningIndicator)) != EqualTo)
1196     return result;
1197   if ((result = m_partySubaddress.Compare(other.m_partySubaddress)) != EqualTo)
1198     return result;
1199
1200   return PASN_Sequence::Compare(other);
1201 }
1202
1203
1204 PINDEX H4501_AddressScreened::GetDataLength() const
1205 {
1206   PINDEX length = 0;
1207   length += m_partyNumber.GetObjectLength();
1208   length += m_screeningIndicator.GetObjectLength();
1209   if (HasOptionalField(e_partySubaddress))
1210     length += m_partySubaddress.GetObjectLength();
1211   return length;
1212 }
1213
1214
1215 BOOL H4501_AddressScreened::Decode(PASN_Stream & strm)
1216 {
1217   if (!PreambleDecode(strm))
1218     return FALSE;
1219
1220   if (!m_partyNumber.Decode(strm))
1221     return FALSE;
1222   if (!m_screeningIndicator.Decode(strm))
1223     return FALSE;
1224   if (HasOptionalField(e_partySubaddress) && !m_partySubaddress.Decode(strm))
1225     return FALSE;
1226
1227   return UnknownExtensionsDecode(strm);
1228 }
1229
1230
1231 void H4501_AddressScreened::Encode(PASN_Stream & strm) const
1232 {
1233   PreambleEncode(strm);
1234
1235   m_partyNumber.Encode(strm);
1236   m_screeningIndicator.Encode(strm);
1237   if (HasOptionalField(e_partySubaddress))
1238     m_partySubaddress.Encode(strm);
1239
1240   UnknownExtensionsEncode(strm);
1241 }
1242
1243
1244 PObject * H4501_AddressScreened::Clone() const
1245 {
1246 #ifndef PASN_LEANANDMEAN
1247   PAssert(IsClass(H4501_AddressScreened::Class()), PInvalidCast);
1248 #endif
1249   return new H4501_AddressScreened(*this);
1250 }
1251
1252
1253 //
1254 // NumberScreened
1255 //
1256
1257 H4501_NumberScreened::H4501_NumberScreened(unsigned tag, PASN_Object::TagClass tagClass)
1258   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
1259 {
1260 }
1261
1262
1263 #ifndef PASN_NOPRINTON
1264 void H4501_NumberScreened::PrintOn(ostream & strm) const
1265 {
1266   int indent = strm.precision() + 2;
1267   strm << "{\n";
1268   strm << setw(indent+14) << "partyNumber = " << setprecision(indent) << m_partyNumber << '\n';
1269   strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
1270   strm << setw(indent-1) << setprecision(indent-2) << "}";
1271 }
1272 #endif
1273
1274
1275 PObject::Comparison H4501_NumberScreened::Compare(const PObject & obj) const
1276 {
1277 #ifndef PASN_LEANANDMEAN
1278   PAssert(PIsDescendant(&obj, H4501_NumberScreened), PInvalidCast);
1279 #endif
1280   const H4501_NumberScreened & other = (const H4501_NumberScreened &)obj;
1281
1282   Comparison result;
1283
1284   if ((result = m_partyNumber.Compare(other.m_partyNumber)) != EqualTo)
1285     return result;
1286   if ((result = m_screeningIndicator.Compare(other.m_screeningIndicator)) != EqualTo)
1287     return result;
1288
1289   return PASN_Sequence::Compare(other);
1290 }
1291
1292
1293 PINDEX H4501_NumberScreened::GetDataLength() const
1294 {
1295   PINDEX length = 0;
1296   length += m_partyNumber.GetObjectLength();
1297   length += m_screeningIndicator.GetObjectLength();
1298   return length;
1299 }
1300
1301
1302 BOOL H4501_NumberScreened::Decode(PASN_Stream & strm)
1303 {
1304   if (!PreambleDecode(strm))
1305     return FALSE;
1306
1307   if (!m_partyNumber.Decode(strm))
1308     return FALSE;
1309   if (!m_screeningIndicator.Decode(strm))
1310     return FALSE;
1311
1312   return UnknownExtensionsDecode(strm);
1313 }
1314
1315
1316 void H4501_NumberScreened::Encode(PASN_Stream & strm) const
1317 {
1318   PreambleEncode(strm);
1319
1320   m_partyNumber.Encode(strm);
1321   m_screeningIndicator.Encode(strm);
1322
1323   UnknownExtensionsEncode(strm);
1324 }
1325
1326
1327 PObject * H4501_NumberScreened::Clone() const
1328 {
1329 #ifndef PASN_LEANANDMEAN
1330   PAssert(IsClass(H4501_NumberScreened::Class()), PInvalidCast);
1331 #endif
1332   return new H4501_NumberScreened(*this);
1333 }
1334
1335
1336 //
1337 // Address
1338 //
1339
1340 H4501_Address::H4501_Address(unsigned tag, PASN_Object::TagClass tagClass)
1341   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
1342 {
1343 }
1344
1345
1346 #ifndef PASN_NOPRINTON
1347 void H4501_Address::PrintOn(ostream & strm) const
1348 {
1349   int indent = strm.precision() + 2;
1350   strm << "{\n";
1351   strm << setw(indent+14) << "partyNumber = " << setprecision(indent) << m_partyNumber << '\n';
1352   if (HasOptionalField(e_partySubaddress))
1353     strm << setw(indent+18) << "partySubaddress = " << setprecision(indent) << m_partySubaddress << '\n';
1354   strm << setw(indent-1) << setprecision(indent-2) << "}";
1355 }
1356 #endif
1357
1358
1359 PObject::Comparison H4501_Address::Compare(const PObject & obj) const
1360 {
1361 #ifndef PASN_LEANANDMEAN
1362   PAssert(PIsDescendant(&obj, H4501_Address), PInvalidCast);
1363 #endif
1364   const H4501_Address & other = (const H4501_Address &)obj;
1365
1366   Comparison result;
1367
1368   if ((result = m_partyNumber.Compare(other.m_partyNumber)) != EqualTo)
1369     return result;
1370   if ((result = m_partySubaddress.Compare(other.m_partySubaddress)) != EqualTo)
1371     return result;
1372
1373   return PASN_Sequence::Compare(other);
1374 }
1375
1376
1377 PINDEX H4501_Address::GetDataLength() const
1378 {
1379   PINDEX length = 0;
1380   length += m_partyNumber.GetObjectLength();
1381   if (HasOptionalField(e_partySubaddress))
1382     length += m_partySubaddress.GetObjectLength();
1383   return length;
1384 }
1385
1386
1387 BOOL H4501_Address::Decode(PASN_Stream & strm)
1388 {
1389   if (!PreambleDecode(strm))
1390     return FALSE;
1391
1392   if (!m_partyNumber.Decode(strm))
1393     return FALSE;
1394   if (HasOptionalField(e_partySubaddress) && !m_partySubaddress.Decode(strm))
1395     return FALSE;
1396
1397   return UnknownExtensionsDecode(strm);
1398 }
1399
1400
1401 void H4501_Address::Encode(PASN_Stream & strm) const
1402 {
1403   PreambleEncode(strm);
1404
1405   m_partyNumber.Encode(strm);
1406   if (HasOptionalField(e_partySubaddress))
1407     m_partySubaddress.Encode(strm);
1408
1409   UnknownExtensionsEncode(strm);
1410 }
1411
1412
1413 PObject * H4501_Address::Clone() const
1414 {
1415 #ifndef PASN_LEANANDMEAN
1416   PAssert(IsClass(H4501_Address::Class()), PInvalidCast);
1417 #endif
1418   return new H4501_Address(*this);
1419 }
1420
1421
1422 //
1423 // EndpointAddress
1424 //
1425
1426 H4501_EndpointAddress::H4501_EndpointAddress(unsigned tag, PASN_Object::TagClass tagClass)
1427   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
1428 {
1429 }
1430
1431
1432 #ifndef PASN_NOPRINTON
1433 void H4501_EndpointAddress::PrintOn(ostream & strm) const
1434 {
1435   int indent = strm.precision() + 2;
1436   strm << "{\n";
1437   strm << setw(indent+21) << "destinationAddress = " << setprecision(indent) << m_destinationAddress << '\n';
1438   if (HasOptionalField(e_remoteExtensionAddress))
1439     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
1440   strm << setw(indent-1) << setprecision(indent-2) << "}";
1441 }
1442 #endif
1443
1444
1445 PObject::Comparison H4501_EndpointAddress::Compare(const PObject & obj) const
1446 {
1447 #ifndef PASN_LEANANDMEAN
1448   PAssert(PIsDescendant(&obj, H4501_EndpointAddress), PInvalidCast);
1449 #endif
1450   const H4501_EndpointAddress & other = (const H4501_EndpointAddress &)obj;
1451
1452   Comparison result;
1453
1454   if ((result = m_destinationAddress.Compare(other.m_destinationAddress)) != EqualTo)
1455     return result;
1456   if ((result = m_remoteExtensionAddress.Compare(other.m_remoteExtensionAddress)) != EqualTo)
1457     return result;
1458
1459   return PASN_Sequence::Compare(other);
1460 }
1461
1462
1463 PINDEX H4501_EndpointAddress::GetDataLength() const
1464 {
1465   PINDEX length = 0;
1466   length += m_destinationAddress.GetObjectLength();
1467   if (HasOptionalField(e_remoteExtensionAddress))
1468     length += m_remoteExtensionAddress.GetObjectLength();
1469   return length;
1470 }
1471
1472
1473 BOOL H4501_EndpointAddress::Decode(PASN_Stream & strm)
1474 {
1475   if (!PreambleDecode(strm))
1476     return FALSE;
1477
1478   if (!m_destinationAddress.Decode(strm))
1479     return FALSE;
1480   if (HasOptionalField(e_remoteExtensionAddress) && !m_remoteExtensionAddress.Decode(strm))
1481     return FALSE;
1482
1483   return UnknownExtensionsDecode(strm);
1484 }
1485
1486
1487 void H4501_EndpointAddress::Encode(PASN_Stream & strm) const
1488 {
1489   PreambleEncode(strm);
1490
1491   m_destinationAddress.Encode(strm);
1492   if (HasOptionalField(e_remoteExtensionAddress))
1493     m_remoteExtensionAddress.Encode(strm);
1494
1495   UnknownExtensionsEncode(strm);
1496 }
1497
1498
1499 PObject * H4501_EndpointAddress::Clone() const
1500 {
1501 #ifndef PASN_LEANANDMEAN
1502   PAssert(IsClass(H4501_EndpointAddress::Class()), PInvalidCast);
1503 #endif
1504   return new H4501_EndpointAddress(*this);
1505 }
1506
1507
1508 //
1509 // UserSpecifiedSubaddress
1510 //
1511
1512 H4501_UserSpecifiedSubaddress::H4501_UserSpecifiedSubaddress(unsigned tag, PASN_Object::TagClass tagClass)
1513   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
1514 {
1515 }
1516
1517
1518 #ifndef PASN_NOPRINTON
1519 void H4501_UserSpecifiedSubaddress::PrintOn(ostream & strm) const
1520 {
1521   int indent = strm.precision() + 2;
1522   strm << "{\n";
1523   strm << setw(indent+24) << "subaddressInformation = " << setprecision(indent) << m_subaddressInformation << '\n';
1524   if (HasOptionalField(e_oddCountIndicator))
1525     strm << setw(indent+20) << "oddCountIndicator = " << setprecision(indent) << m_oddCountIndicator << '\n';
1526   strm << setw(indent-1) << setprecision(indent-2) << "}";
1527 }
1528 #endif
1529
1530
1531 PObject::Comparison H4501_UserSpecifiedSubaddress::Compare(const PObject & obj) const
1532 {
1533 #ifndef PASN_LEANANDMEAN
1534   PAssert(PIsDescendant(&obj, H4501_UserSpecifiedSubaddress), PInvalidCast);
1535 #endif
1536   const H4501_UserSpecifiedSubaddress & other = (const H4501_UserSpecifiedSubaddress &)obj;
1537
1538   Comparison result;
1539
1540   if ((result = m_subaddressInformation.Compare(other.m_subaddressInformation)) != EqualTo)
1541     return result;
1542   if ((result = m_oddCountIndicator.Compare(other.m_oddCountIndicator)) != EqualTo)
1543     return result;
1544
1545   return PASN_Sequence::Compare(other);
1546 }
1547
1548
1549 PINDEX H4501_UserSpecifiedSubaddress::GetDataLength() const
1550 {
1551   PINDEX length = 0;
1552   length += m_subaddressInformation.GetObjectLength();
1553   if (HasOptionalField(e_oddCountIndicator))
1554     length += m_oddCountIndicator.GetObjectLength();
1555   return length;
1556 }
1557
1558
1559 BOOL H4501_UserSpecifiedSubaddress::Decode(PASN_Stream & strm)
1560 {
1561   if (!PreambleDecode(strm))
1562     return FALSE;
1563
1564   if (!m_subaddressInformation.Decode(strm))
1565     return FALSE;
1566   if (HasOptionalField(e_oddCountIndicator) && !m_oddCountIndicator.Decode(strm))
1567     return FALSE;
1568
1569   return UnknownExtensionsDecode(strm);
1570 }
1571
1572
1573 void H4501_UserSpecifiedSubaddress::Encode(PASN_Stream & strm) const
1574 {
1575   PreambleEncode(strm);
1576
1577   m_subaddressInformation.Encode(strm);
1578   if (HasOptionalField(e_oddCountIndicator))
1579     m_oddCountIndicator.Encode(strm);
1580
1581   UnknownExtensionsEncode(strm);
1582 }
1583
1584
1585 PObject * H4501_UserSpecifiedSubaddress::Clone() const
1586 {
1587 #ifndef PASN_LEANANDMEAN
1588   PAssert(IsClass(H4501_UserSpecifiedSubaddress::Class()), PInvalidCast);
1589 #endif
1590   return new H4501_UserSpecifiedSubaddress(*this);
1591 }
1592
1593
1594 //
1595 // SupplementaryService
1596 //
1597
1598 H4501_SupplementaryService::H4501_SupplementaryService(unsigned tag, PASN_Object::TagClass tagClass)
1599   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
1600 {
1601 }
1602
1603
1604 #ifndef PASN_NOPRINTON
1605 void H4501_SupplementaryService::PrintOn(ostream & strm) const
1606 {
1607   int indent = strm.precision() + 2;
1608   strm << "{\n";
1609   if (HasOptionalField(e_networkFacilityExtension))
1610     strm << setw(indent+27) << "networkFacilityExtension = " << setprecision(indent) << m_networkFacilityExtension << '\n';
1611   if (HasOptionalField(e_interpretationApdu))
1612     strm << setw(indent+21) << "interpretationApdu = " << setprecision(indent) << m_interpretationApdu << '\n';
1613   strm << setw(indent+14) << "serviceApdu = " << setprecision(indent) << m_serviceApdu << '\n';
1614   strm << setw(indent-1) << setprecision(indent-2) << "}";
1615 }
1616 #endif
1617
1618
1619 PObject::Comparison H4501_SupplementaryService::Compare(const PObject & obj) const
1620 {
1621 #ifndef PASN_LEANANDMEAN
1622   PAssert(PIsDescendant(&obj, H4501_SupplementaryService), PInvalidCast);
1623 #endif
1624   const H4501_SupplementaryService & other = (const H4501_SupplementaryService &)obj;
1625
1626   Comparison result;
1627
1628   if ((result = m_networkFacilityExtension.Compare(other.m_networkFacilityExtension)) != EqualTo)
1629     return result;
1630   if ((result = m_interpretationApdu.Compare(other.m_interpretationApdu)) != EqualTo)
1631     return result;
1632   if ((result = m_serviceApdu.Compare(other.m_serviceApdu)) != EqualTo)
1633     return result;
1634
1635   return PASN_Sequence::Compare(other);
1636 }
1637
1638
1639 PINDEX H4501_SupplementaryService::GetDataLength() const
1640 {
1641   PINDEX length = 0;
1642   if (HasOptionalField(e_networkFacilityExtension))
1643     length += m_networkFacilityExtension.GetObjectLength();
1644   if (HasOptionalField(e_interpretationApdu))
1645     length += m_interpretationApdu.GetObjectLength();
1646   length += m_serviceApdu.GetObjectLength();
1647   return length;
1648 }
1649
1650
1651 BOOL H4501_SupplementaryService::Decode(PASN_Stream & strm)
1652 {
1653   if (!PreambleDecode(strm))
1654     return FALSE;
1655
1656   if (HasOptionalField(e_networkFacilityExtension) && !m_networkFacilityExtension.Decode(strm))
1657     return FALSE;
1658   if (HasOptionalField(e_interpretationApdu) && !m_interpretationApdu.Decode(strm))
1659     return FALSE;
1660   if (!m_serviceApdu.Decode(strm))
1661     return FALSE;
1662
1663   return UnknownExtensionsDecode(strm);
1664 }
1665
1666
1667 void H4501_SupplementaryService::Encode(PASN_Stream & strm) const
1668 {
1669   PreambleEncode(strm);
1670
1671   if (HasOptionalField(e_networkFacilityExtension))
1672     m_networkFacilityExtension.Encode(strm);
1673   if (HasOptionalField(e_interpretationApdu))
1674     m_interpretationApdu.Encode(strm);
1675   m_serviceApdu.Encode(strm);
1676
1677   UnknownExtensionsEncode(strm);
1678 }
1679
1680
1681 PObject * H4501_SupplementaryService::Clone() const
1682 {
1683 #ifndef PASN_LEANANDMEAN
1684   PAssert(IsClass(H4501_SupplementaryService::Class()), PInvalidCast);
1685 #endif
1686   return new H4501_SupplementaryService(*this);
1687 }
1688
1689
1690 #endif // if ! H323_DISABLE_H4501
1691
1692
1693 // End of h4501.cxx