src/t38.cxx

   1 //
   2 // t38.cxx
   3 //
   4 // Code automatically generated by asnparse.
   5 //
   6
   7 #ifdef P_USE_PRAGMA
   8 #pragma implementation "t38.h"
   9 #endif
  10
  11 #include <ptlib.h>
  12 #include "t38.h"
  13
  14 #define new PNEW
  15
  16
  17 #if ! H323_DISABLE_T38
  18
  19
  20 #ifndef PASN_NOPRINTON
  21 const static PASN_Names Names_T38_Type_of_msg[]={
  22       {"t30_indicator",0}
  23      ,{"data",1}
  24 };
  25 #endif
  26 //
  27 // Type-of-msg
  28 //
  29
  30 T38_Type_of_msg::T38_Type_of_msg(unsigned tag, PASN_Object::TagClass tagClass)
  31   : PASN_Choice(tag, tagClass, 2, FALSE
  32 #ifndef PASN_NOPRINTON
  33     ,(const PASN_Names *)Names_T38_Type_of_msg,2
  34 #endif
  35 )
  36 {
  37 }
  38
  39
  40 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  41 T38_Type_of_msg::operator T38_Type_of_msg_t30_indicator &() const
  42 #else
  43 T38_Type_of_msg::operator T38_Type_of_msg_t30_indicator &()
  44 {
  45 #ifndef PASN_LEANANDMEAN
  46   PAssert(PIsDescendant(PAssertNULL(choice), T38_Type_of_msg_t30_indicator), PInvalidCast);
  47 #endif
  48   return *(T38_Type_of_msg_t30_indicator *)choice;
  49 }
  50
  51
  52 T38_Type_of_msg::operator const T38_Type_of_msg_t30_indicator &() const
  53 #endif
  54 {
  55 #ifndef PASN_LEANANDMEAN
  56   PAssert(PIsDescendant(PAssertNULL(choice), T38_Type_of_msg_t30_indicator), PInvalidCast);
  57 #endif
  58   return *(T38_Type_of_msg_t30_indicator *)choice;
  59 }
  60
  61
  62 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  63 T38_Type_of_msg::operator T38_Type_of_msg_data &() const
  64 #else
  65 T38_Type_of_msg::operator T38_Type_of_msg_data &()
  66 {
  67 #ifndef PASN_LEANANDMEAN
  68   PAssert(PIsDescendant(PAssertNULL(choice), T38_Type_of_msg_data), PInvalidCast);
  69 #endif
  70   return *(T38_Type_of_msg_data *)choice;
  71 }
  72
  73
  74 T38_Type_of_msg::operator const T38_Type_of_msg_data &() const
  75 #endif
  76 {
  77 #ifndef PASN_LEANANDMEAN
  78   PAssert(PIsDescendant(PAssertNULL(choice), T38_Type_of_msg_data), PInvalidCast);
  79 #endif
  80   return *(T38_Type_of_msg_data *)choice;
  81 }
  82
  83
  84 BOOL T38_Type_of_msg::CreateObject()
  85 {
  86   switch (tag) {
  87     case e_t30_indicator :
  88       choice = new T38_Type_of_msg_t30_indicator();
  89       return TRUE;
  90     case e_data :
  91       choice = new T38_Type_of_msg_data();
  92       return TRUE;
  93   }
  94
  95   choice = NULL;
  96   return FALSE;
  97 }
  98
  99
 100 PObject * T38_Type_of_msg::Clone() const
 101 {
 102 #ifndef PASN_LEANANDMEAN
 103   PAssert(IsClass(T38_Type_of_msg::Class()), PInvalidCast);
 104 #endif
 105   return new T38_Type_of_msg(*this);
 106 }
 107
 108
 109 //
 110 // Data-Field
 111 //
 112
 113 T38_Data_Field::T38_Data_Field(unsigned tag, PASN_Object::TagClass tagClass)
 114   : PASN_Array(tag, tagClass)
 115 {
 116 }
 117
 118
 119 PASN_Object * T38_Data_Field::CreateObject() const
 120 {
 121   return new T38_Data_Field_subtype;
 122 }
 123
 124
 125 T38_Data_Field_subtype & T38_Data_Field::operator[](PINDEX i) const
 126 {
 127   return (T38_Data_Field_subtype &)array[i];
 128 }
 129
 130
 131 PObject * T38_Data_Field::Clone() const
 132 {
 133 #ifndef PASN_LEANANDMEAN
 134   PAssert(IsClass(T38_Data_Field::Class()), PInvalidCast);
 135 #endif
 136   return new T38_Data_Field(*this);
 137 }
 138
 139
 140 //
 141 // PreCorrigendum-Data-Field
 142 //
 143
 144 T38_PreCorrigendum_Data_Field::T38_PreCorrigendum_Data_Field(unsigned tag, PASN_Object::TagClass tagClass)
 145   : PASN_Array(tag, tagClass)
 146 {
 147 }
 148
 149
 150 PASN_Object * T38_PreCorrigendum_Data_Field::CreateObject() const
 151 {
 152   return new T38_PreCorrigendum_Data_Field_subtype;
 153 }
 154
 155
 156 T38_PreCorrigendum_Data_Field_subtype & T38_PreCorrigendum_Data_Field::operator[](PINDEX i) const
 157 {
 158   return (T38_PreCorrigendum_Data_Field_subtype &)array[i];
 159 }
 160
 161
 162 PObject * T38_PreCorrigendum_Data_Field::Clone() const
 163 {
 164 #ifndef PASN_LEANANDMEAN
 165   PAssert(IsClass(T38_PreCorrigendum_Data_Field::Class()), PInvalidCast);
 166 #endif
 167   return new T38_PreCorrigendum_Data_Field(*this);
 168 }
 169
 170
 171 #ifndef PASN_NOPRINTON
 172 const static PASN_Names Names_T38_Type_of_msg_t30_indicator[]={
 173         {"no-signal",0}
 174        ,{"cng",1}
 175        ,{"ced",2}
 176        ,{"v21-preamble",3}
 177        ,{"v27-2400-training",4}
 178        ,{"v27-4800-training",5}
 179        ,{"v29-7200-training",6}
 180        ,{"v29-9600-training",7}
 181        ,{"v17-7200-short-training",8}
 182        ,{"v17-7200-long-training",9}
 183        ,{"v17-9600-short-training",10}
 184        ,{"v17-9600-long-training",11}
 185        ,{"v17-12000-short-training",12}
 186        ,{"v17-12000-long-training",13}
 187        ,{"v17-14400-short-training",14}
 188        ,{"v17-14400-long-training",15}
 189 };
 190 #endif
 191 //
 192 // Type-of-msg_t30-indicator
 193 //
 194
 195 T38_Type_of_msg_t30_indicator::T38_Type_of_msg_t30_indicator(unsigned tag, PASN_Object::TagClass tagClass)
 196   : PASN_Enumeration(tag, tagClass, 15, TRUE
 197 #ifndef PASN_NOPRINTON
 198     ,(const PASN_Names *)Names_T38_Type_of_msg_t30_indicator,16
 199 #endif
 200     )
 201 {
 202 }
 203
 204
 205 T38_Type_of_msg_t30_indicator & T38_Type_of_msg_t30_indicator::operator=(unsigned v)
 206 {
 207   SetValue(v);
 208   return *this;
 209 }
 210
 211
 212 PObject * T38_Type_of_msg_t30_indicator::Clone() const
 213 {
 214 #ifndef PASN_LEANANDMEAN
 215   PAssert(IsClass(T38_Type_of_msg_t30_indicator::Class()), PInvalidCast);
 216 #endif
 217   return new T38_Type_of_msg_t30_indicator(*this);
 218 }
 219
 220
 221 #ifndef PASN_NOPRINTON
 222 const static PASN_Names Names_T38_Type_of_msg_data[]={
 223         {"v21",0}
 224        ,{"v27-2400",1}
 225        ,{"v27-4800",2}
 226        ,{"v29-7200",3}
 227        ,{"v29-9600",4}
 228        ,{"v17-7200",5}
 229        ,{"v17-9600",6}
 230        ,{"v17-12000",7}
 231        ,{"v17-14400",8}
 232 };
 233 #endif
 234 //
 235 // Type-of-msg_data
 236 //
 237
 238 T38_Type_of_msg_data::T38_Type_of_msg_data(unsigned tag, PASN_Object::TagClass tagClass)
 239   : PASN_Enumeration(tag, tagClass, 8, TRUE
 240 #ifndef PASN_NOPRINTON
 241     ,(const PASN_Names *)Names_T38_Type_of_msg_data,9
 242 #endif
 243     )
 244 {
 245 }
 246
 247
 248 T38_Type_of_msg_data & T38_Type_of_msg_data::operator=(unsigned v)
 249 {
 250   SetValue(v);
 251   return *this;
 252 }
 253
 254
 255 PObject * T38_Type_of_msg_data::Clone() const
 256 {
 257 #ifndef PASN_LEANANDMEAN
 258   PAssert(IsClass(T38_Type_of_msg_data::Class()), PInvalidCast);
 259 #endif
 260   return new T38_Type_of_msg_data(*this);
 261 }
 262
 263
 264
 265 #ifndef PASN_NOPRINTON
 266 const static PASN_Names Names_T38_UDPTLPacket_error_recovery[]={
 267       {"secondary_ifp_packets",0}
 268      ,{"fec_info",1}
 269 };
 270 #endif
 271 //
 272 // UDPTLPacket_error-recovery
 273 //
 274
 275 T38_UDPTLPacket_error_recovery::T38_UDPTLPacket_error_recovery(unsigned tag, PASN_Object::TagClass tagClass)
 276   : PASN_Choice(tag, tagClass, 2, FALSE
 277 #ifndef PASN_NOPRINTON
 278     ,(const PASN_Names *)Names_T38_UDPTLPacket_error_recovery,2
 279 #endif
 280 )
 281 {
 282 }
 283
 284
 285 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 286 T38_UDPTLPacket_error_recovery::operator T38_UDPTLPacket_error_recovery_secondary_ifp_packets &() const
 287 #else
 288 T38_UDPTLPacket_error_recovery::operator T38_UDPTLPacket_error_recovery_secondary_ifp_packets &()
 289 {
 290 #ifndef PASN_LEANANDMEAN
 291   PAssert(PIsDescendant(PAssertNULL(choice), T38_UDPTLPacket_error_recovery_secondary_ifp_packets), PInvalidCast);
 292 #endif
 293   return *(T38_UDPTLPacket_error_recovery_secondary_ifp_packets *)choice;
 294 }
 295
 296
 297 T38_UDPTLPacket_error_recovery::operator const T38_UDPTLPacket_error_recovery_secondary_ifp_packets &() const
 298 #endif
 299 {
 300 #ifndef PASN_LEANANDMEAN
 301   PAssert(PIsDescendant(PAssertNULL(choice), T38_UDPTLPacket_error_recovery_secondary_ifp_packets), PInvalidCast);
 302 #endif
 303   return *(T38_UDPTLPacket_error_recovery_secondary_ifp_packets *)choice;
 304 }
 305
 306
 307 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 308 T38_UDPTLPacket_error_recovery::operator T38_UDPTLPacket_error_recovery_fec_info &() const
 309 #else
 310 T38_UDPTLPacket_error_recovery::operator T38_UDPTLPacket_error_recovery_fec_info &()
 311 {
 312 #ifndef PASN_LEANANDMEAN
 313   PAssert(PIsDescendant(PAssertNULL(choice), T38_UDPTLPacket_error_recovery_fec_info), PInvalidCast);
 314 #endif
 315   return *(T38_UDPTLPacket_error_recovery_fec_info *)choice;
 316 }
 317
 318
 319 T38_UDPTLPacket_error_recovery::operator const T38_UDPTLPacket_error_recovery_fec_info &() const
 320 #endif
 321 {
 322 #ifndef PASN_LEANANDMEAN
 323   PAssert(PIsDescendant(PAssertNULL(choice), T38_UDPTLPacket_error_recovery_fec_info), PInvalidCast);
 324 #endif
 325   return *(T38_UDPTLPacket_error_recovery_fec_info *)choice;
 326 }
 327
 328
 329 BOOL T38_UDPTLPacket_error_recovery::CreateObject()
 330 {
 331   switch (tag) {
 332     case e_secondary_ifp_packets :
 333       choice = new T38_UDPTLPacket_error_recovery_secondary_ifp_packets();
 334       return TRUE;
 335     case e_fec_info :
 336       choice = new T38_UDPTLPacket_error_recovery_fec_info();
 337       return TRUE;
 338   }
 339
 340   choice = NULL;
 341   return FALSE;
 342 }
 343
 344
 345 PObject * T38_UDPTLPacket_error_recovery::Clone() const
 346 {
 347 #ifndef PASN_LEANANDMEAN
 348   PAssert(IsClass(T38_UDPTLPacket_error_recovery::Class()), PInvalidCast);
 349 #endif
 350   return new T38_UDPTLPacket_error_recovery(*this);
 351 }
 352
 353
 354 #ifndef PASN_NOPRINTON
 355 const static PASN_Names Names_T38_Data_Field_subtype_field_type[]={
 356         {"hdlc-data",0}
 357        ,{"hdlc-sig-end",1}
 358        ,{"hdlc-fcs-OK",2}
 359        ,{"hdlc-fcs-BAD",3}
 360        ,{"hdlc-fcs-OK-sig-end",4}
 361        ,{"hdlc-fcs-BAD-sig-end",5}
 362        ,{"t4-non-ecm-data",6}
 363        ,{"t4-non-ecm-sig-end",7}
 364 };
 365 #endif
 366 //
 367 // Data-Field_subtype_field-type
 368 //
 369
 370 T38_Data_Field_subtype_field_type::T38_Data_Field_subtype_field_type(unsigned tag, PASN_Object::TagClass tagClass)
 371   : PASN_Enumeration(tag, tagClass, 7, TRUE
 372 #ifndef PASN_NOPRINTON
 373     ,(const PASN_Names *)Names_T38_Data_Field_subtype_field_type,8
 374 #endif
 375     )
 376 {
 377 }
 378
 379
 380 T38_Data_Field_subtype_field_type & T38_Data_Field_subtype_field_type::operator=(unsigned v)
 381 {
 382   SetValue(v);
 383   return *this;
 384 }
 385
 386
 387 PObject * T38_Data_Field_subtype_field_type::Clone() const
 388 {
 389 #ifndef PASN_LEANANDMEAN
 390   PAssert(IsClass(T38_Data_Field_subtype_field_type::Class()), PInvalidCast);
 391 #endif
 392   return new T38_Data_Field_subtype_field_type(*this);
 393 }
 394
 395
 396 #ifndef PASN_NOPRINTON
 397 const static PASN_Names Names_T38_PreCorrigendum_Data_Field_subtype_field_type[]={
 398         {"hdlc-data",0}
 399        ,{"hdlc-sig-end",1}
 400        ,{"hdlc-fcs-OK",2}
 401        ,{"hdlc-fcs-BAD",3}
 402        ,{"hdlc-fcs-OK-sig-end",4}
 403        ,{"hdlc-fcs-BAD-sig-end",5}
 404        ,{"t4-non-ecm-data",6}
 405        ,{"t4-non-ecm-sig-end",7}
 406 };
 407 #endif
 408 //
 409 // PreCorrigendum-Data-Field_subtype_field-type
 410 //
 411
 412 T38_PreCorrigendum_Data_Field_subtype_field_type::T38_PreCorrigendum_Data_Field_subtype_field_type(unsigned tag, PASN_Object::TagClass tagClass)
 413   : PASN_Enumeration(tag, tagClass, 7, FALSE
 414 #ifndef PASN_NOPRINTON
 415     ,(const PASN_Names *)Names_T38_PreCorrigendum_Data_Field_subtype_field_type,8
 416 #endif
 417     )
 418 {
 419 }
 420
 421
 422 T38_PreCorrigendum_Data_Field_subtype_field_type & T38_PreCorrigendum_Data_Field_subtype_field_type::operator=(unsigned v)
 423 {
 424   SetValue(v);
 425   return *this;
 426 }
 427
 428
 429 PObject * T38_PreCorrigendum_Data_Field_subtype_field_type::Clone() const
 430 {
 431 #ifndef PASN_LEANANDMEAN
 432   PAssert(IsClass(T38_PreCorrigendum_Data_Field_subtype_field_type::Class()), PInvalidCast);
 433 #endif
 434   return new T38_PreCorrigendum_Data_Field_subtype_field_type(*this);
 435 }
 436
 437
 438 //
 439 // UDPTLPacket_error-recovery_secondary-ifp-packets
 440 //
 441
 442 T38_UDPTLPacket_error_recovery_secondary_ifp_packets::T38_UDPTLPacket_error_recovery_secondary_ifp_packets(unsigned tag, PASN_Object::TagClass tagClass)
 443   : PASN_Array(tag, tagClass)
 444 {
 445 }
 446
 447
 448 PASN_Object * T38_UDPTLPacket_error_recovery_secondary_ifp_packets::CreateObject() const
 449 {
 450   return new T38_UDPTLPacket_error_recovery_secondary_ifp_packets_subtype;
 451 }
 452
 453
 454 T38_UDPTLPacket_error_recovery_secondary_ifp_packets_subtype & T38_UDPTLPacket_error_recovery_secondary_ifp_packets::operator[](PINDEX i) const
 455 {
 456   return (T38_UDPTLPacket_error_recovery_secondary_ifp_packets_subtype &)array[i];
 457 }
 458
 459
 460 PObject * T38_UDPTLPacket_error_recovery_secondary_ifp_packets::Clone() const
 461 {
 462 #ifndef PASN_LEANANDMEAN
 463   PAssert(IsClass(T38_UDPTLPacket_error_recovery_secondary_ifp_packets::Class()), PInvalidCast);
 464 #endif
 465   return new T38_UDPTLPacket_error_recovery_secondary_ifp_packets(*this);
 466 }
 467
 468
 469 //
 470 // ArrayOf_PASN_OctetString
 471 //
 472
 473 T38_ArrayOf_PASN_OctetString::T38_ArrayOf_PASN_OctetString(unsigned tag, PASN_Object::TagClass tagClass)
 474   : PASN_Array(tag, tagClass)
 475 {
 476 }
 477
 478
 479 PASN_Object * T38_ArrayOf_PASN_OctetString::CreateObject() const
 480 {
 481   return new PASN_OctetString;
 482 }
 483
 484
 485 PASN_OctetString & T38_ArrayOf_PASN_OctetString::operator[](PINDEX i) const
 486 {
 487   return (PASN_OctetString &)array[i];
 488 }
 489
 490
 491 PObject * T38_ArrayOf_PASN_OctetString::Clone() const
 492 {
 493 #ifndef PASN_LEANANDMEAN
 494   PAssert(IsClass(T38_ArrayOf_PASN_OctetString::Class()), PInvalidCast);
 495 #endif
 496   return new T38_ArrayOf_PASN_OctetString(*this);
 497 }
 498
 499
 500 //
 501 // IFPPacket
 502 //
 503
 504 T38_IFPPacket::T38_IFPPacket(unsigned tag, PASN_Object::TagClass tagClass)
 505   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
 506 {
 507 }
 508
 509
 510 #ifndef PASN_NOPRINTON
 511 void T38_IFPPacket::PrintOn(ostream & strm) const
 512 {
 513   int indent = strm.precision() + 2;
 514   strm << "{\n";
 515   strm << setw(indent+14) << "type_of_msg = " << setprecision(indent) << m_type_of_msg << '\n';
 516   if (HasOptionalField(e_data_field))
 517     strm << setw(indent+13) << "data_field = " << setprecision(indent) << m_data_field << '\n';
 518   strm << setw(indent-1) << setprecision(indent-2) << "}";
 519 }
 520 #endif
 521
 522
 523 PObject::Comparison T38_IFPPacket::Compare(const PObject & obj) const
 524 {
 525 #ifndef PASN_LEANANDMEAN
 526   PAssert(PIsDescendant(&obj, T38_IFPPacket), PInvalidCast);
 527 #endif
 528   const T38_IFPPacket & other = (const T38_IFPPacket &)obj;
 529
 530   Comparison result;
 531
 532   if ((result = m_type_of_msg.Compare(other.m_type_of_msg)) != EqualTo)
 533     return result;
 534   if ((result = m_data_field.Compare(other.m_data_field)) != EqualTo)
 535     return result;
 536
 537   return PASN_Sequence::Compare(other);
 538 }
 539
 540
 541 PINDEX T38_IFPPacket::GetDataLength() const
 542 {
 543   PINDEX length = 0;
 544   length += m_type_of_msg.GetObjectLength();
 545   if (HasOptionalField(e_data_field))
 546     length += m_data_field.GetObjectLength();
 547   return length;
 548 }
 549
 550
 551 BOOL T38_IFPPacket::Decode(PASN_Stream & strm)
 552 {
 553   if (!PreambleDecode(strm))
 554     return FALSE;
 555
 556   if (!m_type_of_msg.Decode(strm))
 557     return FALSE;
 558   if (HasOptionalField(e_data_field) && !m_data_field.Decode(strm))
 559     return FALSE;
 560
 561   return UnknownExtensionsDecode(strm);
 562 }
 563
 564
 565 void T38_IFPPacket::Encode(PASN_Stream & strm) const
 566 {
 567   PreambleEncode(strm);
 568
 569   m_type_of_msg.Encode(strm);
 570   if (HasOptionalField(e_data_field))
 571     m_data_field.Encode(strm);
 572
 573   UnknownExtensionsEncode(strm);
 574 }
 575
 576
 577 PObject * T38_IFPPacket::Clone() const
 578 {
 579 #ifndef PASN_LEANANDMEAN
 580   PAssert(IsClass(T38_IFPPacket::Class()), PInvalidCast);
 581 #endif
 582   return new T38_IFPPacket(*this);
 583 }
 584
 585
 586 //
 587 // PreCorrigendum-IFPPacket
 588 //
 589
 590 T38_PreCorrigendum_IFPPacket::T38_PreCorrigendum_IFPPacket(unsigned tag, PASN_Object::TagClass tagClass)
 591   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
 592 {
 593 }
 594
 595
 596 #ifndef PASN_NOPRINTON
 597 void T38_PreCorrigendum_IFPPacket::PrintOn(ostream & strm) const
 598 {
 599   int indent = strm.precision() + 2;
 600   strm << "{\n";
 601   strm << setw(indent+14) << "type_of_msg = " << setprecision(indent) << m_type_of_msg << '\n';
 602   if (HasOptionalField(e_data_field))
 603     strm << setw(indent+13) << "data_field = " << setprecision(indent) << m_data_field << '\n';
 604   strm << setw(indent-1) << setprecision(indent-2) << "}";
 605 }
 606 #endif
 607
 608
 609 PObject::Comparison T38_PreCorrigendum_IFPPacket::Compare(const PObject & obj) const
 610 {
 611 #ifndef PASN_LEANANDMEAN
 612   PAssert(PIsDescendant(&obj, T38_PreCorrigendum_IFPPacket), PInvalidCast);
 613 #endif
 614   const T38_PreCorrigendum_IFPPacket & other = (const T38_PreCorrigendum_IFPPacket &)obj;
 615
 616   Comparison result;
 617
 618   if ((result = m_type_of_msg.Compare(other.m_type_of_msg)) != EqualTo)
 619     return result;
 620   if ((result = m_data_field.Compare(other.m_data_field)) != EqualTo)
 621     return result;
 622
 623   return PASN_Sequence::Compare(other);
 624 }
 625
 626
 627 PINDEX T38_PreCorrigendum_IFPPacket::GetDataLength() const
 628 {
 629   PINDEX length = 0;
 630   length += m_type_of_msg.GetObjectLength();
 631   if (HasOptionalField(e_data_field))
 632     length += m_data_field.GetObjectLength();
 633   return length;
 634 }
 635
 636
 637 BOOL T38_PreCorrigendum_IFPPacket::Decode(PASN_Stream & strm)
 638 {
 639   if (!PreambleDecode(strm))
 640     return FALSE;
 641
 642   if (!m_type_of_msg.Decode(strm))
 643     return FALSE;
 644   if (HasOptionalField(e_data_field) && !m_data_field.Decode(strm))
 645     return FALSE;
 646
 647   return UnknownExtensionsDecode(strm);
 648 }
 649
 650
 651 void T38_PreCorrigendum_IFPPacket::Encode(PASN_Stream & strm) const
 652 {
 653   PreambleEncode(strm);
 654
 655   m_type_of_msg.Encode(strm);
 656   if (HasOptionalField(e_data_field))
 657     m_data_field.Encode(strm);
 658
 659   UnknownExtensionsEncode(strm);
 660 }
 661
 662
 663 PObject * T38_PreCorrigendum_IFPPacket::Clone() const
 664 {
 665 #ifndef PASN_LEANANDMEAN
 666   PAssert(IsClass(T38_PreCorrigendum_IFPPacket::Class()), PInvalidCast);
 667 #endif
 668   return new T38_PreCorrigendum_IFPPacket(*this);
 669 }
 670
 671
 672 //
 673 // Data-Field_subtype
 674 //
 675
 676 T38_Data_Field_subtype::T38_Data_Field_subtype(unsigned tag, PASN_Object::TagClass tagClass)
 677   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
 678 {
 679   m_field_data.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
 680 }
 681
 682
 683 #ifndef PASN_NOPRINTON
 684 void T38_Data_Field_subtype::PrintOn(ostream & strm) const
 685 {
 686   int indent = strm.precision() + 2;
 687   strm << "{\n";
 688   strm << setw(indent+13) << "field_type = " << setprecision(indent) << m_field_type << '\n';
 689   if (HasOptionalField(e_field_data))
 690     strm << setw(indent+13) << "field_data = " << setprecision(indent) << m_field_data << '\n';
 691   strm << setw(indent-1) << setprecision(indent-2) << "}";
 692 }
 693 #endif
 694
 695
 696 PObject::Comparison T38_Data_Field_subtype::Compare(const PObject & obj) const
 697 {
 698 #ifndef PASN_LEANANDMEAN
 699   PAssert(PIsDescendant(&obj, T38_Data_Field_subtype), PInvalidCast);
 700 #endif
 701   const T38_Data_Field_subtype & other = (const T38_Data_Field_subtype &)obj;
 702
 703   Comparison result;
 704
 705   if ((result = m_field_type.Compare(other.m_field_type)) != EqualTo)
 706     return result;
 707   if ((result = m_field_data.Compare(other.m_field_data)) != EqualTo)
 708     return result;
 709
 710   return PASN_Sequence::Compare(other);
 711 }
 712
 713
 714 PINDEX T38_Data_Field_subtype::GetDataLength() const
 715 {
 716   PINDEX length = 0;
 717   length += m_field_type.GetObjectLength();
 718   if (HasOptionalField(e_field_data))
 719     length += m_field_data.GetObjectLength();
 720   return length;
 721 }
 722
 723
 724 BOOL T38_Data_Field_subtype::Decode(PASN_Stream & strm)
 725 {
 726   if (!PreambleDecode(strm))
 727     return FALSE;
 728
 729   if (!m_field_type.Decode(strm))
 730     return FALSE;
 731   if (HasOptionalField(e_field_data) && !m_field_data.Decode(strm))
 732     return FALSE;
 733
 734   return UnknownExtensionsDecode(strm);
 735 }
 736
 737
 738 void T38_Data_Field_subtype::Encode(PASN_Stream & strm) const
 739 {
 740   PreambleEncode(strm);
 741
 742   m_field_type.Encode(strm);
 743   if (HasOptionalField(e_field_data))
 744     m_field_data.Encode(strm);
 745
 746   UnknownExtensionsEncode(strm);
 747 }
 748
 749
 750 PObject * T38_Data_Field_subtype::Clone() const
 751 {
 752 #ifndef PASN_LEANANDMEAN
 753   PAssert(IsClass(T38_Data_Field_subtype::Class()), PInvalidCast);
 754 #endif
 755   return new T38_Data_Field_subtype(*this);
 756 }
 757
 758
 759 //
 760 // PreCorrigendum-Data-Field_subtype
 761 //
 762
 763 T38_PreCorrigendum_Data_Field_subtype::T38_PreCorrigendum_Data_Field_subtype(unsigned tag, PASN_Object::TagClass tagClass)
 764   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
 765 {
 766   m_field_data.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
 767 }
 768
 769
 770 #ifndef PASN_NOPRINTON
 771 void T38_PreCorrigendum_Data_Field_subtype::PrintOn(ostream & strm) const
 772 {
 773   int indent = strm.precision() + 2;
 774   strm << "{\n";
 775   strm << setw(indent+13) << "field_type = " << setprecision(indent) << m_field_type << '\n';
 776   if (HasOptionalField(e_field_data))
 777     strm << setw(indent+13) << "field_data = " << setprecision(indent) << m_field_data << '\n';
 778   strm << setw(indent-1) << setprecision(indent-2) << "}";
 779 }
 780 #endif
 781
 782
 783 PObject::Comparison T38_PreCorrigendum_Data_Field_subtype::Compare(const PObject & obj) const
 784 {
 785 #ifndef PASN_LEANANDMEAN
 786   PAssert(PIsDescendant(&obj, T38_PreCorrigendum_Data_Field_subtype), PInvalidCast);
 787 #endif
 788   const T38_PreCorrigendum_Data_Field_subtype & other = (const T38_PreCorrigendum_Data_Field_subtype &)obj;
 789
 790   Comparison result;
 791
 792   if ((result = m_field_type.Compare(other.m_field_type)) != EqualTo)
 793     return result;
 794   if ((result = m_field_data.Compare(other.m_field_data)) != EqualTo)
 795     return result;
 796
 797   return PASN_Sequence::Compare(other);
 798 }
 799
 800
 801 PINDEX T38_PreCorrigendum_Data_Field_subtype::GetDataLength() const
 802 {
 803   PINDEX length = 0;
 804   length += m_field_type.GetObjectLength();
 805   if (HasOptionalField(e_field_data))
 806     length += m_field_data.GetObjectLength();
 807   return length;
 808 }
 809
 810
 811 BOOL T38_PreCorrigendum_Data_Field_subtype::Decode(PASN_Stream & strm)
 812 {
 813   if (!PreambleDecode(strm))
 814     return FALSE;
 815
 816   if (!m_field_type.Decode(strm))
 817     return FALSE;
 818   if (HasOptionalField(e_field_data) && !m_field_data.Decode(strm))
 819     return FALSE;
 820
 821   return UnknownExtensionsDecode(strm);
 822 }
 823
 824
 825 void T38_PreCorrigendum_Data_Field_subtype::Encode(PASN_Stream & strm) const
 826 {
 827   PreambleEncode(strm);
 828
 829   m_field_type.Encode(strm);
 830   if (HasOptionalField(e_field_data))
 831     m_field_data.Encode(strm);
 832
 833   UnknownExtensionsEncode(strm);
 834 }
 835
 836
 837 PObject * T38_PreCorrigendum_Data_Field_subtype::Clone() const
 838 {
 839 #ifndef PASN_LEANANDMEAN
 840   PAssert(IsClass(T38_PreCorrigendum_Data_Field_subtype::Class()), PInvalidCast);
 841 #endif
 842   return new T38_PreCorrigendum_Data_Field_subtype(*this);
 843 }
 844
 845
 846 //
 847 // UDPTLPacket_primary-ifp-packet
 848 //
 849
 850 T38_UDPTLPacket_primary_ifp_packet::T38_UDPTLPacket_primary_ifp_packet(unsigned tag, PASN_Object::TagClass tagClass)
 851   : PASN_OctetString(tag, tagClass)
 852 {
 853 }
 854
 855
 856 PObject * T38_UDPTLPacket_primary_ifp_packet::Clone() const
 857 {
 858 #ifndef PASN_LEANANDMEAN
 859   PAssert(IsClass(T38_UDPTLPacket_primary_ifp_packet::Class()), PInvalidCast);
 860 #endif
 861   return new T38_UDPTLPacket_primary_ifp_packet(*this);
 862 }
 863
 864
 865 //
 866 // UDPTLPacket_error-recovery_fec-info
 867 //
 868
 869 T38_UDPTLPacket_error_recovery_fec_info::T38_UDPTLPacket_error_recovery_fec_info(unsigned tag, PASN_Object::TagClass tagClass)
 870   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
 871 {
 872 }
 873
 874
 875 #ifndef PASN_NOPRINTON
 876 void T38_UDPTLPacket_error_recovery_fec_info::PrintOn(ostream & strm) const
 877 {
 878   int indent = strm.precision() + 2;
 879   strm << "{\n";
 880   strm << setw(indent+15) << "fec_npackets = " << setprecision(indent) << m_fec_npackets << '\n';
 881   strm << setw(indent+11) << "fec_data = " << setprecision(indent) << m_fec_data << '\n';
 882   strm << setw(indent-1) << setprecision(indent-2) << "}";
 883 }
 884 #endif
 885
 886
 887 PObject::Comparison T38_UDPTLPacket_error_recovery_fec_info::Compare(const PObject & obj) const
 888 {
 889 #ifndef PASN_LEANANDMEAN
 890   PAssert(PIsDescendant(&obj, T38_UDPTLPacket_error_recovery_fec_info), PInvalidCast);
 891 #endif
 892   const T38_UDPTLPacket_error_recovery_fec_info & other = (const T38_UDPTLPacket_error_recovery_fec_info &)obj;
 893
 894   Comparison result;
 895
 896   if ((result = m_fec_npackets.Compare(other.m_fec_npackets)) != EqualTo)
 897     return result;
 898   if ((result = m_fec_data.Compare(other.m_fec_data)) != EqualTo)
 899     return result;
 900
 901   return PASN_Sequence::Compare(other);
 902 }
 903
 904
 905 PINDEX T38_UDPTLPacket_error_recovery_fec_info::GetDataLength() const
 906 {
 907   PINDEX length = 0;
 908   length += m_fec_npackets.GetObjectLength();
 909   length += m_fec_data.GetObjectLength();
 910   return length;
 911 }
 912
 913
 914 BOOL T38_UDPTLPacket_error_recovery_fec_info::Decode(PASN_Stream & strm)
 915 {
 916   if (!PreambleDecode(strm))
 917     return FALSE;
 918
 919   if (!m_fec_npackets.Decode(strm))
 920     return FALSE;
 921   if (!m_fec_data.Decode(strm))
 922     return FALSE;
 923
 924   return UnknownExtensionsDecode(strm);
 925 }
 926
 927
 928 void T38_UDPTLPacket_error_recovery_fec_info::Encode(PASN_Stream & strm) const
 929 {
 930   PreambleEncode(strm);
 931
 932   m_fec_npackets.Encode(strm);
 933   m_fec_data.Encode(strm);
 934
 935   UnknownExtensionsEncode(strm);
 936 }
 937
 938
 939 PObject * T38_UDPTLPacket_error_recovery_fec_info::Clone() const
 940 {
 941 #ifndef PASN_LEANANDMEAN
 942   PAssert(IsClass(T38_UDPTLPacket_error_recovery_fec_info::Class()), PInvalidCast);
 943 #endif
 944   return new T38_UDPTLPacket_error_recovery_fec_info(*this);
 945 }
 946
 947
 948 //
 949 // UDPTLPacket_error-recovery_secondary-ifp-packets_subtype
 950 //
 951
 952 T38_UDPTLPacket_error_recovery_secondary_ifp_packets_subtype::T38_UDPTLPacket_error_recovery_secondary_ifp_packets_subtype(unsigned tag, PASN_Object::TagClass tagClass)
 953   : PASN_OctetString(tag, tagClass)
 954 {
 955 }
 956
 957
 958 PObject * T38_UDPTLPacket_error_recovery_secondary_ifp_packets_subtype::Clone() const
 959 {
 960 #ifndef PASN_LEANANDMEAN
 961   PAssert(IsClass(T38_UDPTLPacket_error_recovery_secondary_ifp_packets_subtype::Class()), PInvalidCast);
 962 #endif
 963   return new T38_UDPTLPacket_error_recovery_secondary_ifp_packets_subtype(*this);
 964 }
 965
 966
 967 //
 968 // UDPTLPacket
 969 //
 970
 971 T38_UDPTLPacket::T38_UDPTLPacket(unsigned tag, PASN_Object::TagClass tagClass)
 972   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
 973 {
 974   m_seq_number.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
 975 }
 976
 977
 978 #ifndef PASN_NOPRINTON
 979 void T38_UDPTLPacket::PrintOn(ostream & strm) const
 980 {
 981   int indent = strm.precision() + 2;
 982   strm << "{\n";
 983   strm << setw(indent+13) << "seq_number = " << setprecision(indent) << m_seq_number << '\n';
 984   strm << setw(indent+21) << "primary_ifp_packet = " << setprecision(indent) << m_primary_ifp_packet << '\n';
 985   strm << setw(indent+17) << "error_recovery = " << setprecision(indent) << m_error_recovery << '\n';
 986   strm << setw(indent-1) << setprecision(indent-2) << "}";
 987 }
 988 #endif
 989
 990
 991 PObject::Comparison T38_UDPTLPacket::Compare(const PObject & obj) const
 992 {
 993 #ifndef PASN_LEANANDMEAN
 994   PAssert(PIsDescendant(&obj, T38_UDPTLPacket), PInvalidCast);
 995 #endif
 996   const T38_UDPTLPacket & other = (const T38_UDPTLPacket &)obj;
 997
 998   Comparison result;
 999
1000   if ((result = m_seq_number.Compare(other.m_seq_number)) != EqualTo)
1001     return result;
1002   if ((result = m_primary_ifp_packet.Compare(other.m_primary_ifp_packet)) != EqualTo)
1003     return result;
1004   if ((result = m_error_recovery.Compare(other.m_error_recovery)) != EqualTo)
1005     return result;
1006
1007   return PASN_Sequence::Compare(other);
1008 }
1009
1010
1011 PINDEX T38_UDPTLPacket::GetDataLength() const
1012 {
1013   PINDEX length = 0;
1014   length += m_seq_number.GetObjectLength();
1015   length += m_primary_ifp_packet.GetObjectLength();
1016   length += m_error_recovery.GetObjectLength();
1017   return length;
1018 }
1019
1020
1021 BOOL T38_UDPTLPacket::Decode(PASN_Stream & strm)
1022 {
1023   if (!PreambleDecode(strm))
1024     return FALSE;
1025
1026   if (!m_seq_number.Decode(strm))
1027     return FALSE;
1028   if (!m_primary_ifp_packet.Decode(strm))
1029     return FALSE;
1030   if (!m_error_recovery.Decode(strm))
1031     return FALSE;
1032
1033   return UnknownExtensionsDecode(strm);
1034 }
1035
1036
1037 void T38_UDPTLPacket::Encode(PASN_Stream & strm) const
1038 {
1039   PreambleEncode(strm);
1040
1041   m_seq_number.Encode(strm);
1042   m_primary_ifp_packet.Encode(strm);
1043   m_error_recovery.Encode(strm);
1044
1045   UnknownExtensionsEncode(strm);
1046 }
1047
1048
1049 PObject * T38_UDPTLPacket::Clone() const
1050 {
1051 #ifndef PASN_LEANANDMEAN
1052   PAssert(IsClass(T38_UDPTLPacket::Class()), PInvalidCast);
1053 #endif
1054   return new T38_UDPTLPacket(*this);
1055 }
1056
1057
1058 #endif // if ! H323_DISABLE_T38
1059
1060
1061 // End of t38.cxx