home *** CD-ROM | disk | FTP | other *** search
/ ftp.muug.mb.ca / 2014.06.ftp.muug.mb.ca.tar / ftp.muug.mb.ca / pub / openh323.tar.gz / openh323.tar / openh323 / src / h225_2.cxx < prev    next >
C/C++ Source or Header  |  2004-06-22  |  436KB  |  13,198 lines
  1. //
  2. // h225_2.cxx
  3. //
  4. // Code automatically generated by asnparse.
  5. //
  6.  
  7. #include <ptlib.h>
  8. #include "h225.h"
  9.  
  10. #define new PNEW
  11.  
  12.  
  13. #if ! H323_DISABLE_H225
  14.  
  15. //
  16. // CallCreditServiceControl_callStartingPoint
  17. //
  18.  
  19. H225_CallCreditServiceControl_callStartingPoint::H225_CallCreditServiceControl_callStartingPoint(unsigned tag, PASN_Object::TagClass tagClass)
  20.   : PASN_Choice(tag, tagClass, 2, TRUE
  21. #ifndef PASN_NOPRINTON
  22.       , "alerting "
  23.         "connect "
  24. #endif
  25.     )
  26. {
  27. }
  28.  
  29.  
  30. BOOL H225_CallCreditServiceControl_callStartingPoint::CreateObject()
  31. {
  32.   choice = (tag <= e_connect) ? new PASN_Null() : NULL;
  33.   return choice != NULL;
  34. }
  35.  
  36.  
  37. PObject * H225_CallCreditServiceControl_callStartingPoint::Clone() const
  38. {
  39. #ifndef PASN_LEANANDMEAN
  40.   PAssert(IsClass(H225_CallCreditServiceControl_callStartingPoint::Class()), PInvalidCast);
  41. #endif
  42.   return new H225_CallCreditServiceControl_callStartingPoint(*this);
  43. }
  44.  
  45.  
  46. //
  47. // ArrayOf_EnumeratedParameter
  48. //
  49.  
  50. H225_ArrayOf_EnumeratedParameter::H225_ArrayOf_EnumeratedParameter(unsigned tag, PASN_Object::TagClass tagClass)
  51.   : PASN_Array(tag, tagClass)
  52. {
  53. }
  54.  
  55.  
  56. PASN_Object * H225_ArrayOf_EnumeratedParameter::CreateObject() const
  57. {
  58.   return new H225_EnumeratedParameter;
  59. }
  60.  
  61.  
  62. H225_EnumeratedParameter & H225_ArrayOf_EnumeratedParameter::operator[](PINDEX i) const
  63. {
  64.   return (H225_EnumeratedParameter &)array[i];
  65. }
  66.  
  67.  
  68. PObject * H225_ArrayOf_EnumeratedParameter::Clone() const
  69. {
  70. #ifndef PASN_LEANANDMEAN
  71.   PAssert(IsClass(H225_ArrayOf_EnumeratedParameter::Class()), PInvalidCast);
  72. #endif
  73.   return new H225_ArrayOf_EnumeratedParameter(*this);
  74. }
  75.  
  76.  
  77. //
  78. // RTPSession_associatedSessionIds
  79. //
  80.  
  81. H225_RTPSession_associatedSessionIds::H225_RTPSession_associatedSessionIds(unsigned tag, PASN_Object::TagClass tagClass)
  82.   : PASN_Array(tag, tagClass)
  83. {
  84. }
  85.  
  86.  
  87. PASN_Object * H225_RTPSession_associatedSessionIds::CreateObject() const
  88. {
  89.   PASN_Integer * obj = new PASN_Integer;
  90.   obj->SetConstraints(PASN_Object::FixedConstraint, 1, 255);
  91.   return obj;
  92. }
  93.  
  94.  
  95. PASN_Integer & H225_RTPSession_associatedSessionIds::operator[](PINDEX i) const
  96. {
  97.   return (PASN_Integer &)array[i];
  98. }
  99.  
  100.  
  101. PObject * H225_RTPSession_associatedSessionIds::Clone() const
  102. {
  103. #ifndef PASN_LEANANDMEAN
  104.   PAssert(IsClass(H225_RTPSession_associatedSessionIds::Class()), PInvalidCast);
  105. #endif
  106.   return new H225_RTPSession_associatedSessionIds(*this);
  107. }
  108.  
  109.  
  110. //
  111. // ArrayOf_Endpoint
  112. //
  113.  
  114. H225_ArrayOf_Endpoint::H225_ArrayOf_Endpoint(unsigned tag, PASN_Object::TagClass tagClass)
  115.   : PASN_Array(tag, tagClass)
  116. {
  117. }
  118.  
  119.  
  120. PASN_Object * H225_ArrayOf_Endpoint::CreateObject() const
  121. {
  122.   return new H225_Endpoint;
  123. }
  124.  
  125.  
  126. H225_Endpoint & H225_ArrayOf_Endpoint::operator[](PINDEX i) const
  127. {
  128.   return (H225_Endpoint &)array[i];
  129. }
  130.  
  131.  
  132. PObject * H225_ArrayOf_Endpoint::Clone() const
  133. {
  134. #ifndef PASN_LEANANDMEAN
  135.   PAssert(IsClass(H225_ArrayOf_Endpoint::Class()), PInvalidCast);
  136. #endif
  137.   return new H225_ArrayOf_Endpoint(*this);
  138. }
  139.  
  140.  
  141. //
  142. // ArrayOf_AuthenticationMechanism
  143. //
  144.  
  145. H225_ArrayOf_AuthenticationMechanism::H225_ArrayOf_AuthenticationMechanism(unsigned tag, PASN_Object::TagClass tagClass)
  146.   : PASN_Array(tag, tagClass)
  147. {
  148. }
  149.  
  150.  
  151. PASN_Object * H225_ArrayOf_AuthenticationMechanism::CreateObject() const
  152. {
  153.   return new H235_AuthenticationMechanism;
  154. }
  155.  
  156.  
  157. H235_AuthenticationMechanism & H225_ArrayOf_AuthenticationMechanism::operator[](PINDEX i) const
  158. {
  159.   return (H235_AuthenticationMechanism &)array[i];
  160. }
  161.  
  162.  
  163. PObject * H225_ArrayOf_AuthenticationMechanism::Clone() const
  164. {
  165. #ifndef PASN_LEANANDMEAN
  166.   PAssert(IsClass(H225_ArrayOf_AuthenticationMechanism::Class()), PInvalidCast);
  167. #endif
  168.   return new H225_ArrayOf_AuthenticationMechanism(*this);
  169. }
  170.  
  171.  
  172. //
  173. // ArrayOf_PASN_ObjectId
  174. //
  175.  
  176. H225_ArrayOf_PASN_ObjectId::H225_ArrayOf_PASN_ObjectId(unsigned tag, PASN_Object::TagClass tagClass)
  177.   : PASN_Array(tag, tagClass)
  178. {
  179. }
  180.  
  181.  
  182. PASN_Object * H225_ArrayOf_PASN_ObjectId::CreateObject() const
  183. {
  184.   return new PASN_ObjectId;
  185. }
  186.  
  187.  
  188. PASN_ObjectId & H225_ArrayOf_PASN_ObjectId::operator[](PINDEX i) const
  189. {
  190.   return (PASN_ObjectId &)array[i];
  191. }
  192.  
  193.  
  194. PObject * H225_ArrayOf_PASN_ObjectId::Clone() const
  195. {
  196. #ifndef PASN_LEANANDMEAN
  197.   PAssert(IsClass(H225_ArrayOf_PASN_ObjectId::Class()), PInvalidCast);
  198. #endif
  199.   return new H225_ArrayOf_PASN_ObjectId(*this);
  200. }
  201.  
  202.  
  203. //
  204. // ArrayOf_IntegrityMechanism
  205. //
  206.  
  207. H225_ArrayOf_IntegrityMechanism::H225_ArrayOf_IntegrityMechanism(unsigned tag, PASN_Object::TagClass tagClass)
  208.   : PASN_Array(tag, tagClass)
  209. {
  210. }
  211.  
  212.  
  213. PASN_Object * H225_ArrayOf_IntegrityMechanism::CreateObject() const
  214. {
  215.   return new H225_IntegrityMechanism;
  216. }
  217.  
  218.  
  219. H225_IntegrityMechanism & H225_ArrayOf_IntegrityMechanism::operator[](PINDEX i) const
  220. {
  221.   return (H225_IntegrityMechanism &)array[i];
  222. }
  223.  
  224.  
  225. PObject * H225_ArrayOf_IntegrityMechanism::Clone() const
  226. {
  227. #ifndef PASN_LEANANDMEAN
  228.   PAssert(IsClass(H225_ArrayOf_IntegrityMechanism::Class()), PInvalidCast);
  229. #endif
  230.   return new H225_ArrayOf_IntegrityMechanism(*this);
  231. }
  232.  
  233.  
  234. //
  235. // ArrayOf_AddressPattern
  236. //
  237.  
  238. H225_ArrayOf_AddressPattern::H225_ArrayOf_AddressPattern(unsigned tag, PASN_Object::TagClass tagClass)
  239.   : PASN_Array(tag, tagClass)
  240. {
  241. }
  242.  
  243.  
  244. PASN_Object * H225_ArrayOf_AddressPattern::CreateObject() const
  245. {
  246.   return new H225_AddressPattern;
  247. }
  248.  
  249.  
  250. H225_AddressPattern & H225_ArrayOf_AddressPattern::operator[](PINDEX i) const
  251. {
  252.   return (H225_AddressPattern &)array[i];
  253. }
  254.  
  255.  
  256. PObject * H225_ArrayOf_AddressPattern::Clone() const
  257. {
  258. #ifndef PASN_LEANANDMEAN
  259.   PAssert(IsClass(H225_ArrayOf_AddressPattern::Class()), PInvalidCast);
  260. #endif
  261.   return new H225_ArrayOf_AddressPattern(*this);
  262. }
  263.  
  264.  
  265. //
  266. // ArrayOf_H248PackagesDescriptor
  267. //
  268.  
  269. H225_ArrayOf_H248PackagesDescriptor::H225_ArrayOf_H248PackagesDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
  270.   : PASN_Array(tag, tagClass)
  271. {
  272. }
  273.  
  274.  
  275. PASN_Object * H225_ArrayOf_H248PackagesDescriptor::CreateObject() const
  276. {
  277.   return new H225_H248PackagesDescriptor;
  278. }
  279.  
  280.  
  281. H225_H248PackagesDescriptor & H225_ArrayOf_H248PackagesDescriptor::operator[](PINDEX i) const
  282. {
  283.   return (H225_H248PackagesDescriptor &)array[i];
  284. }
  285.  
  286.  
  287. PObject * H225_ArrayOf_H248PackagesDescriptor::Clone() const
  288. {
  289. #ifndef PASN_LEANANDMEAN
  290.   PAssert(IsClass(H225_ArrayOf_H248PackagesDescriptor::Class()), PInvalidCast);
  291. #endif
  292.   return new H225_ArrayOf_H248PackagesDescriptor(*this);
  293. }
  294.  
  295.  
  296. //
  297. // ArrayOf_RasUsageSpecification
  298. //
  299.  
  300. H225_ArrayOf_RasUsageSpecification::H225_ArrayOf_RasUsageSpecification(unsigned tag, PASN_Object::TagClass tagClass)
  301.   : PASN_Array(tag, tagClass)
  302. {
  303. }
  304.  
  305.  
  306. PASN_Object * H225_ArrayOf_RasUsageSpecification::CreateObject() const
  307. {
  308.   return new H225_RasUsageSpecification;
  309. }
  310.  
  311.  
  312. H225_RasUsageSpecification & H225_ArrayOf_RasUsageSpecification::operator[](PINDEX i) const
  313. {
  314.   return (H225_RasUsageSpecification &)array[i];
  315. }
  316.  
  317.  
  318. PObject * H225_ArrayOf_RasUsageSpecification::Clone() const
  319. {
  320. #ifndef PASN_LEANANDMEAN
  321.   PAssert(IsClass(H225_ArrayOf_RasUsageSpecification::Class()), PInvalidCast);
  322. #endif
  323.   return new H225_ArrayOf_RasUsageSpecification(*this);
  324. }
  325.  
  326.  
  327. //
  328. // RegistrationRejectReason_invalidTerminalAliases
  329. //
  330.  
  331. H225_RegistrationRejectReason_invalidTerminalAliases::H225_RegistrationRejectReason_invalidTerminalAliases(unsigned tag, PASN_Object::TagClass tagClass)
  332.   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
  333. {
  334. }
  335.  
  336.  
  337. #ifndef PASN_NOPRINTON
  338. void H225_RegistrationRejectReason_invalidTerminalAliases::PrintOn(ostream & strm) const
  339. {
  340.   int indent = strm.precision() + 2;
  341.   strm << "{\n";
  342.   if (HasOptionalField(e_terminalAlias))
  343.     strm << setw(indent+16) << "terminalAlias = " << setprecision(indent) << m_terminalAlias << '\n';
  344.   if (HasOptionalField(e_terminalAliasPattern))
  345.     strm << setw(indent+23) << "terminalAliasPattern = " << setprecision(indent) << m_terminalAliasPattern << '\n';
  346.   if (HasOptionalField(e_supportedPrefixes))
  347.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  348.   strm << setw(indent-1) << "}";
  349. }
  350. #endif
  351.  
  352.  
  353. PObject::Comparison H225_RegistrationRejectReason_invalidTerminalAliases::Compare(const PObject & obj) const
  354. {
  355. #ifndef PASN_LEANANDMEAN
  356.   PAssert(IsDescendant(H225_RegistrationRejectReason_invalidTerminalAliases::Class()), PInvalidCast);
  357. #endif
  358.   const H225_RegistrationRejectReason_invalidTerminalAliases & other = (const H225_RegistrationRejectReason_invalidTerminalAliases &)obj;
  359.  
  360.   Comparison result;
  361.  
  362.   if ((result = m_terminalAlias.Compare(other.m_terminalAlias)) != EqualTo)
  363.     return result;
  364.   if ((result = m_terminalAliasPattern.Compare(other.m_terminalAliasPattern)) != EqualTo)
  365.     return result;
  366.   if ((result = m_supportedPrefixes.Compare(other.m_supportedPrefixes)) != EqualTo)
  367.     return result;
  368.  
  369.   return PASN_Sequence::Compare(other);
  370. }
  371.  
  372.  
  373. PINDEX H225_RegistrationRejectReason_invalidTerminalAliases::GetDataLength() const
  374. {
  375.   PINDEX length = 0;
  376.   if (HasOptionalField(e_terminalAlias))
  377.     length += m_terminalAlias.GetObjectLength();
  378.   if (HasOptionalField(e_terminalAliasPattern))
  379.     length += m_terminalAliasPattern.GetObjectLength();
  380.   if (HasOptionalField(e_supportedPrefixes))
  381.     length += m_supportedPrefixes.GetObjectLength();
  382.   return length;
  383. }
  384.  
  385.  
  386. BOOL H225_RegistrationRejectReason_invalidTerminalAliases::Decode(PASN_Stream & strm)
  387. {
  388.   if (!PreambleDecode(strm))
  389.     return FALSE;
  390.  
  391.   if (HasOptionalField(e_terminalAlias) && !m_terminalAlias.Decode(strm))
  392.     return FALSE;
  393.   if (HasOptionalField(e_terminalAliasPattern) && !m_terminalAliasPattern.Decode(strm))
  394.     return FALSE;
  395.   if (HasOptionalField(e_supportedPrefixes) && !m_supportedPrefixes.Decode(strm))
  396.     return FALSE;
  397.  
  398.   return UnknownExtensionsDecode(strm);
  399. }
  400.  
  401.  
  402. void H225_RegistrationRejectReason_invalidTerminalAliases::Encode(PASN_Stream & strm) const
  403. {
  404.   PreambleEncode(strm);
  405.  
  406.   if (HasOptionalField(e_terminalAlias))
  407.     m_terminalAlias.Encode(strm);
  408.   if (HasOptionalField(e_terminalAliasPattern))
  409.     m_terminalAliasPattern.Encode(strm);
  410.   if (HasOptionalField(e_supportedPrefixes))
  411.     m_supportedPrefixes.Encode(strm);
  412.  
  413.   UnknownExtensionsEncode(strm);
  414. }
  415.  
  416.  
  417. PObject * H225_RegistrationRejectReason_invalidTerminalAliases::Clone() const
  418. {
  419. #ifndef PASN_LEANANDMEAN
  420.   PAssert(IsClass(H225_RegistrationRejectReason_invalidTerminalAliases::Class()), PInvalidCast);
  421. #endif
  422.   return new H225_RegistrationRejectReason_invalidTerminalAliases(*this);
  423. }
  424.  
  425.  
  426. //
  427. // AdmissionConfirm_language
  428. //
  429.  
  430. H225_AdmissionConfirm_language::H225_AdmissionConfirm_language(unsigned tag, PASN_Object::TagClass tagClass)
  431.   : PASN_Array(tag, tagClass)
  432. {
  433. }
  434.  
  435.  
  436. PASN_Object * H225_AdmissionConfirm_language::CreateObject() const
  437. {
  438.   PASN_IA5String * obj = new PASN_IA5String;
  439.   obj->SetConstraints(PASN_Object::FixedConstraint, 1, 32);
  440.   return obj;
  441. }
  442.  
  443.  
  444. PASN_IA5String & H225_AdmissionConfirm_language::operator[](PINDEX i) const
  445. {
  446.   return (PASN_IA5String &)array[i];
  447. }
  448.  
  449.  
  450. PObject * H225_AdmissionConfirm_language::Clone() const
  451. {
  452. #ifndef PASN_LEANANDMEAN
  453.   PAssert(IsClass(H225_AdmissionConfirm_language::Class()), PInvalidCast);
  454. #endif
  455.   return new H225_AdmissionConfirm_language(*this);
  456. }
  457.  
  458.  
  459. //
  460. // ArrayOf_PartyNumber
  461. //
  462.  
  463. H225_ArrayOf_PartyNumber::H225_ArrayOf_PartyNumber(unsigned tag, PASN_Object::TagClass tagClass)
  464.   : PASN_Array(tag, tagClass)
  465. {
  466. }
  467.  
  468.  
  469. PASN_Object * H225_ArrayOf_PartyNumber::CreateObject() const
  470. {
  471.   return new H225_PartyNumber;
  472. }
  473.  
  474.  
  475. H225_PartyNumber & H225_ArrayOf_PartyNumber::operator[](PINDEX i) const
  476. {
  477.   return (H225_PartyNumber &)array[i];
  478. }
  479.  
  480.  
  481. PObject * H225_ArrayOf_PartyNumber::Clone() const
  482. {
  483. #ifndef PASN_LEANANDMEAN
  484.   PAssert(IsClass(H225_ArrayOf_PartyNumber::Class()), PInvalidCast);
  485. #endif
  486.   return new H225_ArrayOf_PartyNumber(*this);
  487. }
  488.  
  489.  
  490. //
  491. // ArrayOf_BandwidthDetails
  492. //
  493.  
  494. H225_ArrayOf_BandwidthDetails::H225_ArrayOf_BandwidthDetails(unsigned tag, PASN_Object::TagClass tagClass)
  495.   : PASN_Array(tag, tagClass)
  496. {
  497. }
  498.  
  499.  
  500. PASN_Object * H225_ArrayOf_BandwidthDetails::CreateObject() const
  501. {
  502.   return new H225_BandwidthDetails;
  503. }
  504.  
  505.  
  506. H225_BandwidthDetails & H225_ArrayOf_BandwidthDetails::operator[](PINDEX i) const
  507. {
  508.   return (H225_BandwidthDetails &)array[i];
  509. }
  510.  
  511.  
  512. PObject * H225_ArrayOf_BandwidthDetails::Clone() const
  513. {
  514. #ifndef PASN_LEANANDMEAN
  515.   PAssert(IsClass(H225_ArrayOf_BandwidthDetails::Class()), PInvalidCast);
  516. #endif
  517.   return new H225_ArrayOf_BandwidthDetails(*this);
  518. }
  519.  
  520.  
  521. //
  522. // InfoRequestResponse_perCallInfo
  523. //
  524.  
  525. H225_InfoRequestResponse_perCallInfo::H225_InfoRequestResponse_perCallInfo(unsigned tag, PASN_Object::TagClass tagClass)
  526.   : PASN_Array(tag, tagClass)
  527. {
  528. }
  529.  
  530.  
  531. PASN_Object * H225_InfoRequestResponse_perCallInfo::CreateObject() const
  532. {
  533.   return new H225_InfoRequestResponse_perCallInfo_subtype;
  534. }
  535.  
  536.  
  537. H225_InfoRequestResponse_perCallInfo_subtype & H225_InfoRequestResponse_perCallInfo::operator[](PINDEX i) const
  538. {
  539.   return (H225_InfoRequestResponse_perCallInfo_subtype &)array[i];
  540. }
  541.  
  542.  
  543. PObject * H225_InfoRequestResponse_perCallInfo::Clone() const
  544. {
  545. #ifndef PASN_LEANANDMEAN
  546.   PAssert(IsClass(H225_InfoRequestResponse_perCallInfo::Class()), PInvalidCast);
  547. #endif
  548.   return new H225_InfoRequestResponse_perCallInfo(*this);
  549. }
  550.  
  551.  
  552. //
  553. // ServiceControlIndication_callSpecific
  554. //
  555.  
  556. H225_ServiceControlIndication_callSpecific::H225_ServiceControlIndication_callSpecific(unsigned tag, PASN_Object::TagClass tagClass)
  557.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  558. {
  559. }
  560.  
  561.  
  562. #ifndef PASN_NOPRINTON
  563. void H225_ServiceControlIndication_callSpecific::PrintOn(ostream & strm) const
  564. {
  565.   int indent = strm.precision() + 2;
  566.   strm << "{\n";
  567.   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  568.   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  569.   strm << setw(indent+15) << "answeredCall = " << setprecision(indent) << m_answeredCall << '\n';
  570.   strm << setw(indent-1) << "}";
  571. }
  572. #endif
  573.  
  574.  
  575. PObject::Comparison H225_ServiceControlIndication_callSpecific::Compare(const PObject & obj) const
  576. {
  577. #ifndef PASN_LEANANDMEAN
  578.   PAssert(IsDescendant(H225_ServiceControlIndication_callSpecific::Class()), PInvalidCast);
  579. #endif
  580.   const H225_ServiceControlIndication_callSpecific & other = (const H225_ServiceControlIndication_callSpecific &)obj;
  581.  
  582.   Comparison result;
  583.  
  584.   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
  585.     return result;
  586.   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
  587.     return result;
  588.   if ((result = m_answeredCall.Compare(other.m_answeredCall)) != EqualTo)
  589.     return result;
  590.  
  591.   return PASN_Sequence::Compare(other);
  592. }
  593.  
  594.  
  595. PINDEX H225_ServiceControlIndication_callSpecific::GetDataLength() const
  596. {
  597.   PINDEX length = 0;
  598.   length += m_callIdentifier.GetObjectLength();
  599.   length += m_conferenceID.GetObjectLength();
  600.   length += m_answeredCall.GetObjectLength();
  601.   return length;
  602. }
  603.  
  604.  
  605. BOOL H225_ServiceControlIndication_callSpecific::Decode(PASN_Stream & strm)
  606. {
  607.   if (!PreambleDecode(strm))
  608.     return FALSE;
  609.  
  610.   if (!m_callIdentifier.Decode(strm))
  611.     return FALSE;
  612.   if (!m_conferenceID.Decode(strm))
  613.     return FALSE;
  614.   if (!m_answeredCall.Decode(strm))
  615.     return FALSE;
  616.  
  617.   return UnknownExtensionsDecode(strm);
  618. }
  619.  
  620.  
  621. void H225_ServiceControlIndication_callSpecific::Encode(PASN_Stream & strm) const
  622. {
  623.   PreambleEncode(strm);
  624.  
  625.   m_callIdentifier.Encode(strm);
  626.   m_conferenceID.Encode(strm);
  627.   m_answeredCall.Encode(strm);
  628.  
  629.   UnknownExtensionsEncode(strm);
  630. }
  631.  
  632.  
  633. PObject * H225_ServiceControlIndication_callSpecific::Clone() const
  634. {
  635. #ifndef PASN_LEANANDMEAN
  636.   PAssert(IsClass(H225_ServiceControlIndication_callSpecific::Class()), PInvalidCast);
  637. #endif
  638.   return new H225_ServiceControlIndication_callSpecific(*this);
  639. }
  640.  
  641.  
  642. //
  643. // ServiceControlResponse_result
  644. //
  645.  
  646. H225_ServiceControlResponse_result::H225_ServiceControlResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  647.   : PASN_Choice(tag, tagClass, 5, TRUE
  648. #ifndef PASN_NOPRINTON
  649.       , "started "
  650.         "failed "
  651.         "stopped "
  652.         "notAvailable "
  653.         "neededFeatureNotSupported "
  654. #endif
  655.     )
  656. {
  657. }
  658.  
  659.  
  660. BOOL H225_ServiceControlResponse_result::CreateObject()
  661. {
  662.   choice = (tag <= e_neededFeatureNotSupported) ? new PASN_Null() : NULL;
  663.   return choice != NULL;
  664. }
  665.  
  666.  
  667. PObject * H225_ServiceControlResponse_result::Clone() const
  668. {
  669. #ifndef PASN_LEANANDMEAN
  670.   PAssert(IsClass(H225_ServiceControlResponse_result::Class()), PInvalidCast);
  671. #endif
  672.   return new H225_ServiceControlResponse_result(*this);
  673. }
  674.  
  675.  
  676. //
  677. // TransportAddress_ipSourceRoute_route
  678. //
  679.  
  680. H225_TransportAddress_ipSourceRoute_route::H225_TransportAddress_ipSourceRoute_route(unsigned tag, PASN_Object::TagClass tagClass)
  681.   : PASN_Array(tag, tagClass)
  682. {
  683. }
  684.  
  685.  
  686. PASN_Object * H225_TransportAddress_ipSourceRoute_route::CreateObject() const
  687. {
  688.   PASN_OctetString * obj = new PASN_OctetString;
  689.   obj->SetConstraints(PASN_Object::FixedConstraint, 4);
  690.   return obj;
  691. }
  692.  
  693.  
  694. PASN_OctetString & H225_TransportAddress_ipSourceRoute_route::operator[](PINDEX i) const
  695. {
  696.   return (PASN_OctetString &)array[i];
  697. }
  698.  
  699.  
  700. PObject * H225_TransportAddress_ipSourceRoute_route::Clone() const
  701. {
  702. #ifndef PASN_LEANANDMEAN
  703.   PAssert(IsClass(H225_TransportAddress_ipSourceRoute_route::Class()), PInvalidCast);
  704. #endif
  705.   return new H225_TransportAddress_ipSourceRoute_route(*this);
  706. }
  707.  
  708.  
  709. //
  710. // TransportAddress_ipSourceRoute_routing
  711. //
  712.  
  713. H225_TransportAddress_ipSourceRoute_routing::H225_TransportAddress_ipSourceRoute_routing(unsigned tag, PASN_Object::TagClass tagClass)
  714.   : PASN_Choice(tag, tagClass, 2, TRUE
  715. #ifndef PASN_NOPRINTON
  716.       , "strict "
  717.         "loose "
  718. #endif
  719.     )
  720. {
  721. }
  722.  
  723.  
  724. BOOL H225_TransportAddress_ipSourceRoute_routing::CreateObject()
  725. {
  726.   choice = (tag <= e_loose) ? new PASN_Null() : NULL;
  727.   return choice != NULL;
  728. }
  729.  
  730.  
  731. PObject * H225_TransportAddress_ipSourceRoute_routing::Clone() const
  732. {
  733. #ifndef PASN_LEANANDMEAN
  734.   PAssert(IsClass(H225_TransportAddress_ipSourceRoute_routing::Class()), PInvalidCast);
  735. #endif
  736.   return new H225_TransportAddress_ipSourceRoute_routing(*this);
  737. }
  738.  
  739.  
  740. //
  741. // ArrayOf_RTPSession
  742. //
  743.  
  744. H225_ArrayOf_RTPSession::H225_ArrayOf_RTPSession(unsigned tag, PASN_Object::TagClass tagClass)
  745.   : PASN_Array(tag, tagClass)
  746. {
  747. }
  748.  
  749.  
  750. PASN_Object * H225_ArrayOf_RTPSession::CreateObject() const
  751. {
  752.   return new H225_RTPSession;
  753. }
  754.  
  755.  
  756. H225_RTPSession & H225_ArrayOf_RTPSession::operator[](PINDEX i) const
  757. {
  758.   return (H225_RTPSession &)array[i];
  759. }
  760.  
  761.  
  762. PObject * H225_ArrayOf_RTPSession::Clone() const
  763. {
  764. #ifndef PASN_LEANANDMEAN
  765.   PAssert(IsClass(H225_ArrayOf_RTPSession::Class()), PInvalidCast);
  766. #endif
  767.   return new H225_ArrayOf_RTPSession(*this);
  768. }
  769.  
  770.  
  771. //
  772. // ArrayOf_TransportChannelInfo
  773. //
  774.  
  775. H225_ArrayOf_TransportChannelInfo::H225_ArrayOf_TransportChannelInfo(unsigned tag, PASN_Object::TagClass tagClass)
  776.   : PASN_Array(tag, tagClass)
  777. {
  778. }
  779.  
  780.  
  781. PASN_Object * H225_ArrayOf_TransportChannelInfo::CreateObject() const
  782. {
  783.   return new H225_TransportChannelInfo;
  784. }
  785.  
  786.  
  787. H225_TransportChannelInfo & H225_ArrayOf_TransportChannelInfo::operator[](PINDEX i) const
  788. {
  789.   return (H225_TransportChannelInfo &)array[i];
  790. }
  791.  
  792.  
  793. PObject * H225_ArrayOf_TransportChannelInfo::Clone() const
  794. {
  795. #ifndef PASN_LEANANDMEAN
  796.   PAssert(IsClass(H225_ArrayOf_TransportChannelInfo::Class()), PInvalidCast);
  797. #endif
  798.   return new H225_ArrayOf_TransportChannelInfo(*this);
  799. }
  800.  
  801.  
  802. //
  803. // ArrayOf_ConferenceIdentifier
  804. //
  805.  
  806. H225_ArrayOf_ConferenceIdentifier::H225_ArrayOf_ConferenceIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
  807.   : PASN_Array(tag, tagClass)
  808. {
  809. }
  810.  
  811.  
  812. PASN_Object * H225_ArrayOf_ConferenceIdentifier::CreateObject() const
  813. {
  814.   return new H225_ConferenceIdentifier;
  815. }
  816.  
  817.  
  818. H225_ConferenceIdentifier & H225_ArrayOf_ConferenceIdentifier::operator[](PINDEX i) const
  819. {
  820.   return (H225_ConferenceIdentifier &)array[i];
  821. }
  822.  
  823.  
  824. PObject * H225_ArrayOf_ConferenceIdentifier::Clone() const
  825. {
  826. #ifndef PASN_LEANANDMEAN
  827.   PAssert(IsClass(H225_ArrayOf_ConferenceIdentifier::Class()), PInvalidCast);
  828. #endif
  829.   return new H225_ArrayOf_ConferenceIdentifier(*this);
  830. }
  831.  
  832.  
  833. //
  834. // InfoRequestResponse_perCallInfo_subtype_pdu
  835. //
  836.  
  837. H225_InfoRequestResponse_perCallInfo_subtype_pdu::H225_InfoRequestResponse_perCallInfo_subtype_pdu(unsigned tag, PASN_Object::TagClass tagClass)
  838.   : PASN_Array(tag, tagClass)
  839. {
  840. }
  841.  
  842.  
  843. PASN_Object * H225_InfoRequestResponse_perCallInfo_subtype_pdu::CreateObject() const
  844. {
  845.   return new H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype;
  846. }
  847.  
  848.  
  849. H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype & H225_InfoRequestResponse_perCallInfo_subtype_pdu::operator[](PINDEX i) const
  850. {
  851.   return (H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype &)array[i];
  852. }
  853.  
  854.  
  855. PObject * H225_InfoRequestResponse_perCallInfo_subtype_pdu::Clone() const
  856. {
  857. #ifndef PASN_LEANANDMEAN
  858.   PAssert(IsClass(H225_InfoRequestResponse_perCallInfo_subtype_pdu::Class()), PInvalidCast);
  859. #endif
  860.   return new H225_InfoRequestResponse_perCallInfo_subtype_pdu(*this);
  861. }
  862.  
  863.  
  864. //
  865. // Status-UUIE
  866. //
  867.  
  868. H225_Status_UUIE::H225_Status_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  869.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  870. {
  871. }
  872.  
  873.  
  874. #ifndef PASN_NOPRINTON
  875. void H225_Status_UUIE::PrintOn(ostream & strm) const
  876. {
  877.   int indent = strm.precision() + 2;
  878.   strm << "{\n";
  879.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  880.   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  881.   if (HasOptionalField(e_tokens))
  882.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  883.   if (HasOptionalField(e_cryptoTokens))
  884.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  885.   strm << setw(indent-1) << "}";
  886. }
  887. #endif
  888.  
  889.  
  890. PObject::Comparison H225_Status_UUIE::Compare(const PObject & obj) const
  891. {
  892. #ifndef PASN_LEANANDMEAN
  893.   PAssert(IsDescendant(H225_Status_UUIE::Class()), PInvalidCast);
  894. #endif
  895.   const H225_Status_UUIE & other = (const H225_Status_UUIE &)obj;
  896.  
  897.   Comparison result;
  898.  
  899.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  900.     return result;
  901.   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
  902.     return result;
  903.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  904.     return result;
  905.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  906.     return result;
  907.  
  908.   return PASN_Sequence::Compare(other);
  909. }
  910.  
  911.  
  912. PINDEX H225_Status_UUIE::GetDataLength() const
  913. {
  914.   PINDEX length = 0;
  915.   length += m_protocolIdentifier.GetObjectLength();
  916.   length += m_callIdentifier.GetObjectLength();
  917.   if (HasOptionalField(e_tokens))
  918.     length += m_tokens.GetObjectLength();
  919.   if (HasOptionalField(e_cryptoTokens))
  920.     length += m_cryptoTokens.GetObjectLength();
  921.   return length;
  922. }
  923.  
  924.  
  925. BOOL H225_Status_UUIE::Decode(PASN_Stream & strm)
  926. {
  927.   if (!PreambleDecode(strm))
  928.     return FALSE;
  929.  
  930.   if (!m_protocolIdentifier.Decode(strm))
  931.     return FALSE;
  932.   if (!m_callIdentifier.Decode(strm))
  933.     return FALSE;
  934.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  935.     return FALSE;
  936.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  937.     return FALSE;
  938.  
  939.   return UnknownExtensionsDecode(strm);
  940. }
  941.  
  942.  
  943. void H225_Status_UUIE::Encode(PASN_Stream & strm) const
  944. {
  945.   PreambleEncode(strm);
  946.  
  947.   m_protocolIdentifier.Encode(strm);
  948.   m_callIdentifier.Encode(strm);
  949.   if (HasOptionalField(e_tokens))
  950.     m_tokens.Encode(strm);
  951.   if (HasOptionalField(e_cryptoTokens))
  952.     m_cryptoTokens.Encode(strm);
  953.  
  954.   UnknownExtensionsEncode(strm);
  955. }
  956.  
  957.  
  958. PObject * H225_Status_UUIE::Clone() const
  959. {
  960. #ifndef PASN_LEANANDMEAN
  961.   PAssert(IsClass(H225_Status_UUIE::Class()), PInvalidCast);
  962. #endif
  963.   return new H225_Status_UUIE(*this);
  964. }
  965.  
  966.  
  967. //
  968. // StatusInquiry-UUIE
  969. //
  970.  
  971. H225_StatusInquiry_UUIE::H225_StatusInquiry_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  972.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  973. {
  974. }
  975.  
  976.  
  977. #ifndef PASN_NOPRINTON
  978. void H225_StatusInquiry_UUIE::PrintOn(ostream & strm) const
  979. {
  980.   int indent = strm.precision() + 2;
  981.   strm << "{\n";
  982.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  983.   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  984.   if (HasOptionalField(e_tokens))
  985.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  986.   if (HasOptionalField(e_cryptoTokens))
  987.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  988.   strm << setw(indent-1) << "}";
  989. }
  990. #endif
  991.  
  992.  
  993. PObject::Comparison H225_StatusInquiry_UUIE::Compare(const PObject & obj) const
  994. {
  995. #ifndef PASN_LEANANDMEAN
  996.   PAssert(IsDescendant(H225_StatusInquiry_UUIE::Class()), PInvalidCast);
  997. #endif
  998.   const H225_StatusInquiry_UUIE & other = (const H225_StatusInquiry_UUIE &)obj;
  999.  
  1000.   Comparison result;
  1001.  
  1002.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  1003.     return result;
  1004.   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
  1005.     return result;
  1006.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  1007.     return result;
  1008.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  1009.     return result;
  1010.  
  1011.   return PASN_Sequence::Compare(other);
  1012. }
  1013.  
  1014.  
  1015. PINDEX H225_StatusInquiry_UUIE::GetDataLength() const
  1016. {
  1017.   PINDEX length = 0;
  1018.   length += m_protocolIdentifier.GetObjectLength();
  1019.   length += m_callIdentifier.GetObjectLength();
  1020.   if (HasOptionalField(e_tokens))
  1021.     length += m_tokens.GetObjectLength();
  1022.   if (HasOptionalField(e_cryptoTokens))
  1023.     length += m_cryptoTokens.GetObjectLength();
  1024.   return length;
  1025. }
  1026.  
  1027.  
  1028. BOOL H225_StatusInquiry_UUIE::Decode(PASN_Stream & strm)
  1029. {
  1030.   if (!PreambleDecode(strm))
  1031.     return FALSE;
  1032.  
  1033.   if (!m_protocolIdentifier.Decode(strm))
  1034.     return FALSE;
  1035.   if (!m_callIdentifier.Decode(strm))
  1036.     return FALSE;
  1037.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  1038.     return FALSE;
  1039.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  1040.     return FALSE;
  1041.  
  1042.   return UnknownExtensionsDecode(strm);
  1043. }
  1044.  
  1045.  
  1046. void H225_StatusInquiry_UUIE::Encode(PASN_Stream & strm) const
  1047. {
  1048.   PreambleEncode(strm);
  1049.  
  1050.   m_protocolIdentifier.Encode(strm);
  1051.   m_callIdentifier.Encode(strm);
  1052.   if (HasOptionalField(e_tokens))
  1053.     m_tokens.Encode(strm);
  1054.   if (HasOptionalField(e_cryptoTokens))
  1055.     m_cryptoTokens.Encode(strm);
  1056.  
  1057.   UnknownExtensionsEncode(strm);
  1058. }
  1059.  
  1060.  
  1061. PObject * H225_StatusInquiry_UUIE::Clone() const
  1062. {
  1063. #ifndef PASN_LEANANDMEAN
  1064.   PAssert(IsClass(H225_StatusInquiry_UUIE::Class()), PInvalidCast);
  1065. #endif
  1066.   return new H225_StatusInquiry_UUIE(*this);
  1067. }
  1068.  
  1069.  
  1070. //
  1071. // SetupAcknowledge-UUIE
  1072. //
  1073.  
  1074. H225_SetupAcknowledge_UUIE::H225_SetupAcknowledge_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  1075.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  1076. {
  1077. }
  1078.  
  1079.  
  1080. #ifndef PASN_NOPRINTON
  1081. void H225_SetupAcknowledge_UUIE::PrintOn(ostream & strm) const
  1082. {
  1083.   int indent = strm.precision() + 2;
  1084.   strm << "{\n";
  1085.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  1086.   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  1087.   if (HasOptionalField(e_tokens))
  1088.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  1089.   if (HasOptionalField(e_cryptoTokens))
  1090.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  1091.   strm << setw(indent-1) << "}";
  1092. }
  1093. #endif
  1094.  
  1095.  
  1096. PObject::Comparison H225_SetupAcknowledge_UUIE::Compare(const PObject & obj) const
  1097. {
  1098. #ifndef PASN_LEANANDMEAN
  1099.   PAssert(IsDescendant(H225_SetupAcknowledge_UUIE::Class()), PInvalidCast);
  1100. #endif
  1101.   const H225_SetupAcknowledge_UUIE & other = (const H225_SetupAcknowledge_UUIE &)obj;
  1102.  
  1103.   Comparison result;
  1104.  
  1105.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  1106.     return result;
  1107.   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
  1108.     return result;
  1109.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  1110.     return result;
  1111.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  1112.     return result;
  1113.  
  1114.   return PASN_Sequence::Compare(other);
  1115. }
  1116.  
  1117.  
  1118. PINDEX H225_SetupAcknowledge_UUIE::GetDataLength() const
  1119. {
  1120.   PINDEX length = 0;
  1121.   length += m_protocolIdentifier.GetObjectLength();
  1122.   length += m_callIdentifier.GetObjectLength();
  1123.   if (HasOptionalField(e_tokens))
  1124.     length += m_tokens.GetObjectLength();
  1125.   if (HasOptionalField(e_cryptoTokens))
  1126.     length += m_cryptoTokens.GetObjectLength();
  1127.   return length;
  1128. }
  1129.  
  1130.  
  1131. BOOL H225_SetupAcknowledge_UUIE::Decode(PASN_Stream & strm)
  1132. {
  1133.   if (!PreambleDecode(strm))
  1134.     return FALSE;
  1135.  
  1136.   if (!m_protocolIdentifier.Decode(strm))
  1137.     return FALSE;
  1138.   if (!m_callIdentifier.Decode(strm))
  1139.     return FALSE;
  1140.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  1141.     return FALSE;
  1142.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  1143.     return FALSE;
  1144.  
  1145.   return UnknownExtensionsDecode(strm);
  1146. }
  1147.  
  1148.  
  1149. void H225_SetupAcknowledge_UUIE::Encode(PASN_Stream & strm) const
  1150. {
  1151.   PreambleEncode(strm);
  1152.  
  1153.   m_protocolIdentifier.Encode(strm);
  1154.   m_callIdentifier.Encode(strm);
  1155.   if (HasOptionalField(e_tokens))
  1156.     m_tokens.Encode(strm);
  1157.   if (HasOptionalField(e_cryptoTokens))
  1158.     m_cryptoTokens.Encode(strm);
  1159.  
  1160.   UnknownExtensionsEncode(strm);
  1161. }
  1162.  
  1163.  
  1164. PObject * H225_SetupAcknowledge_UUIE::Clone() const
  1165. {
  1166. #ifndef PASN_LEANANDMEAN
  1167.   PAssert(IsClass(H225_SetupAcknowledge_UUIE::Class()), PInvalidCast);
  1168. #endif
  1169.   return new H225_SetupAcknowledge_UUIE(*this);
  1170. }
  1171.  
  1172.  
  1173. //
  1174. // Notify-UUIE
  1175. //
  1176.  
  1177. H225_Notify_UUIE::H225_Notify_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  1178.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  1179. {
  1180. }
  1181.  
  1182.  
  1183. #ifndef PASN_NOPRINTON
  1184. void H225_Notify_UUIE::PrintOn(ostream & strm) const
  1185. {
  1186.   int indent = strm.precision() + 2;
  1187.   strm << "{\n";
  1188.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  1189.   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  1190.   if (HasOptionalField(e_tokens))
  1191.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  1192.   if (HasOptionalField(e_cryptoTokens))
  1193.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  1194.   strm << setw(indent-1) << "}";
  1195. }
  1196. #endif
  1197.  
  1198.  
  1199. PObject::Comparison H225_Notify_UUIE::Compare(const PObject & obj) const
  1200. {
  1201. #ifndef PASN_LEANANDMEAN
  1202.   PAssert(IsDescendant(H225_Notify_UUIE::Class()), PInvalidCast);
  1203. #endif
  1204.   const H225_Notify_UUIE & other = (const H225_Notify_UUIE &)obj;
  1205.  
  1206.   Comparison result;
  1207.  
  1208.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  1209.     return result;
  1210.   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
  1211.     return result;
  1212.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  1213.     return result;
  1214.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  1215.     return result;
  1216.  
  1217.   return PASN_Sequence::Compare(other);
  1218. }
  1219.  
  1220.  
  1221. PINDEX H225_Notify_UUIE::GetDataLength() const
  1222. {
  1223.   PINDEX length = 0;
  1224.   length += m_protocolIdentifier.GetObjectLength();
  1225.   length += m_callIdentifier.GetObjectLength();
  1226.   if (HasOptionalField(e_tokens))
  1227.     length += m_tokens.GetObjectLength();
  1228.   if (HasOptionalField(e_cryptoTokens))
  1229.     length += m_cryptoTokens.GetObjectLength();
  1230.   return length;
  1231. }
  1232.  
  1233.  
  1234. BOOL H225_Notify_UUIE::Decode(PASN_Stream & strm)
  1235. {
  1236.   if (!PreambleDecode(strm))
  1237.     return FALSE;
  1238.  
  1239.   if (!m_protocolIdentifier.Decode(strm))
  1240.     return FALSE;
  1241.   if (!m_callIdentifier.Decode(strm))
  1242.     return FALSE;
  1243.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  1244.     return FALSE;
  1245.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  1246.     return FALSE;
  1247.  
  1248.   return UnknownExtensionsDecode(strm);
  1249. }
  1250.  
  1251.  
  1252. void H225_Notify_UUIE::Encode(PASN_Stream & strm) const
  1253. {
  1254.   PreambleEncode(strm);
  1255.  
  1256.   m_protocolIdentifier.Encode(strm);
  1257.   m_callIdentifier.Encode(strm);
  1258.   if (HasOptionalField(e_tokens))
  1259.     m_tokens.Encode(strm);
  1260.   if (HasOptionalField(e_cryptoTokens))
  1261.     m_cryptoTokens.Encode(strm);
  1262.  
  1263.   UnknownExtensionsEncode(strm);
  1264. }
  1265.  
  1266.  
  1267. PObject * H225_Notify_UUIE::Clone() const
  1268. {
  1269. #ifndef PASN_LEANANDMEAN
  1270.   PAssert(IsClass(H225_Notify_UUIE::Class()), PInvalidCast);
  1271. #endif
  1272.   return new H225_Notify_UUIE(*this);
  1273. }
  1274.  
  1275.  
  1276. //
  1277. // VendorIdentifier
  1278. //
  1279.  
  1280. H225_VendorIdentifier::H225_VendorIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
  1281.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  1282. {
  1283.   m_productId.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  1284.   m_versionId.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  1285. }
  1286.  
  1287.  
  1288. #ifndef PASN_NOPRINTON
  1289. void H225_VendorIdentifier::PrintOn(ostream & strm) const
  1290. {
  1291.   int indent = strm.precision() + 2;
  1292.   strm << "{\n";
  1293.   strm << setw(indent+9) << "vendor = " << setprecision(indent) << m_vendor << '\n';
  1294.   if (HasOptionalField(e_productId))
  1295.     strm << setw(indent+12) << "productId = " << setprecision(indent) << m_productId << '\n';
  1296.   if (HasOptionalField(e_versionId))
  1297.     strm << setw(indent+12) << "versionId = " << setprecision(indent) << m_versionId << '\n';
  1298.   strm << setw(indent-1) << "}";
  1299. }
  1300. #endif
  1301.  
  1302.  
  1303. PObject::Comparison H225_VendorIdentifier::Compare(const PObject & obj) const
  1304. {
  1305. #ifndef PASN_LEANANDMEAN
  1306.   PAssert(IsDescendant(H225_VendorIdentifier::Class()), PInvalidCast);
  1307. #endif
  1308.   const H225_VendorIdentifier & other = (const H225_VendorIdentifier &)obj;
  1309.  
  1310.   Comparison result;
  1311.  
  1312.   if ((result = m_vendor.Compare(other.m_vendor)) != EqualTo)
  1313.     return result;
  1314.   if ((result = m_productId.Compare(other.m_productId)) != EqualTo)
  1315.     return result;
  1316.   if ((result = m_versionId.Compare(other.m_versionId)) != EqualTo)
  1317.     return result;
  1318.  
  1319.   return PASN_Sequence::Compare(other);
  1320. }
  1321.  
  1322.  
  1323. PINDEX H225_VendorIdentifier::GetDataLength() const
  1324. {
  1325.   PINDEX length = 0;
  1326.   length += m_vendor.GetObjectLength();
  1327.   if (HasOptionalField(e_productId))
  1328.     length += m_productId.GetObjectLength();
  1329.   if (HasOptionalField(e_versionId))
  1330.     length += m_versionId.GetObjectLength();
  1331.   return length;
  1332. }
  1333.  
  1334.  
  1335. BOOL H225_VendorIdentifier::Decode(PASN_Stream & strm)
  1336. {
  1337.   if (!PreambleDecode(strm))
  1338.     return FALSE;
  1339.  
  1340.   if (!m_vendor.Decode(strm))
  1341.     return FALSE;
  1342.   if (HasOptionalField(e_productId) && !m_productId.Decode(strm))
  1343.     return FALSE;
  1344.   if (HasOptionalField(e_versionId) && !m_versionId.Decode(strm))
  1345.     return FALSE;
  1346.  
  1347.   return UnknownExtensionsDecode(strm);
  1348. }
  1349.  
  1350.  
  1351. void H225_VendorIdentifier::Encode(PASN_Stream & strm) const
  1352. {
  1353.   PreambleEncode(strm);
  1354.  
  1355.   m_vendor.Encode(strm);
  1356.   if (HasOptionalField(e_productId))
  1357.     m_productId.Encode(strm);
  1358.   if (HasOptionalField(e_versionId))
  1359.     m_versionId.Encode(strm);
  1360.  
  1361.   UnknownExtensionsEncode(strm);
  1362. }
  1363.  
  1364.  
  1365. PObject * H225_VendorIdentifier::Clone() const
  1366. {
  1367. #ifndef PASN_LEANANDMEAN
  1368.   PAssert(IsClass(H225_VendorIdentifier::Class()), PInvalidCast);
  1369. #endif
  1370.   return new H225_VendorIdentifier(*this);
  1371. }
  1372.  
  1373.  
  1374. //
  1375. // TunnelledProtocol
  1376. //
  1377.  
  1378. H225_TunnelledProtocol::H225_TunnelledProtocol(unsigned tag, PASN_Object::TagClass tagClass)
  1379.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  1380. {
  1381.   m_subIdentifier.SetConstraints(PASN_Object::FixedConstraint, 1, 64);
  1382. }
  1383.  
  1384.  
  1385. #ifndef PASN_NOPRINTON
  1386. void H225_TunnelledProtocol::PrintOn(ostream & strm) const
  1387. {
  1388.   int indent = strm.precision() + 2;
  1389.   strm << "{\n";
  1390.   strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
  1391.   if (HasOptionalField(e_subIdentifier))
  1392.     strm << setw(indent+16) << "subIdentifier = " << setprecision(indent) << m_subIdentifier << '\n';
  1393.   strm << setw(indent-1) << "}";
  1394. }
  1395. #endif
  1396.  
  1397.  
  1398. PObject::Comparison H225_TunnelledProtocol::Compare(const PObject & obj) const
  1399. {
  1400. #ifndef PASN_LEANANDMEAN
  1401.   PAssert(IsDescendant(H225_TunnelledProtocol::Class()), PInvalidCast);
  1402. #endif
  1403.   const H225_TunnelledProtocol & other = (const H225_TunnelledProtocol &)obj;
  1404.  
  1405.   Comparison result;
  1406.  
  1407.   if ((result = m_id.Compare(other.m_id)) != EqualTo)
  1408.     return result;
  1409.   if ((result = m_subIdentifier.Compare(other.m_subIdentifier)) != EqualTo)
  1410.     return result;
  1411.  
  1412.   return PASN_Sequence::Compare(other);
  1413. }
  1414.  
  1415.  
  1416. PINDEX H225_TunnelledProtocol::GetDataLength() const
  1417. {
  1418.   PINDEX length = 0;
  1419.   length += m_id.GetObjectLength();
  1420.   if (HasOptionalField(e_subIdentifier))
  1421.     length += m_subIdentifier.GetObjectLength();
  1422.   return length;
  1423. }
  1424.  
  1425.  
  1426. BOOL H225_TunnelledProtocol::Decode(PASN_Stream & strm)
  1427. {
  1428.   if (!PreambleDecode(strm))
  1429.     return FALSE;
  1430.  
  1431.   if (!m_id.Decode(strm))
  1432.     return FALSE;
  1433.   if (HasOptionalField(e_subIdentifier) && !m_subIdentifier.Decode(strm))
  1434.     return FALSE;
  1435.  
  1436.   return UnknownExtensionsDecode(strm);
  1437. }
  1438.  
  1439.  
  1440. void H225_TunnelledProtocol::Encode(PASN_Stream & strm) const
  1441. {
  1442.   PreambleEncode(strm);
  1443.  
  1444.   m_id.Encode(strm);
  1445.   if (HasOptionalField(e_subIdentifier))
  1446.     m_subIdentifier.Encode(strm);
  1447.  
  1448.   UnknownExtensionsEncode(strm);
  1449. }
  1450.  
  1451.  
  1452. PObject * H225_TunnelledProtocol::Clone() const
  1453. {
  1454. #ifndef PASN_LEANANDMEAN
  1455.   PAssert(IsClass(H225_TunnelledProtocol::Class()), PInvalidCast);
  1456. #endif
  1457.   return new H225_TunnelledProtocol(*this);
  1458. }
  1459.  
  1460.  
  1461. //
  1462. // NonStandardParameter
  1463. //
  1464.  
  1465. H225_NonStandardParameter::H225_NonStandardParameter(unsigned tag, PASN_Object::TagClass tagClass)
  1466.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1467. {
  1468. }
  1469.  
  1470.  
  1471. #ifndef PASN_NOPRINTON
  1472. void H225_NonStandardParameter::PrintOn(ostream & strm) const
  1473. {
  1474.   int indent = strm.precision() + 2;
  1475.   strm << "{\n";
  1476.   strm << setw(indent+24) << "nonStandardIdentifier = " << setprecision(indent) << m_nonStandardIdentifier << '\n';
  1477.   strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
  1478.   strm << setw(indent-1) << "}";
  1479. }
  1480. #endif
  1481.  
  1482.  
  1483. PObject::Comparison H225_NonStandardParameter::Compare(const PObject & obj) const
  1484. {
  1485. #ifndef PASN_LEANANDMEAN
  1486.   PAssert(IsDescendant(H225_NonStandardParameter::Class()), PInvalidCast);
  1487. #endif
  1488.   const H225_NonStandardParameter & other = (const H225_NonStandardParameter &)obj;
  1489.  
  1490.   Comparison result;
  1491.  
  1492.   if ((result = m_nonStandardIdentifier.Compare(other.m_nonStandardIdentifier)) != EqualTo)
  1493.     return result;
  1494.   if ((result = m_data.Compare(other.m_data)) != EqualTo)
  1495.     return result;
  1496.  
  1497.   return PASN_Sequence::Compare(other);
  1498. }
  1499.  
  1500.  
  1501. PINDEX H225_NonStandardParameter::GetDataLength() const
  1502. {
  1503.   PINDEX length = 0;
  1504.   length += m_nonStandardIdentifier.GetObjectLength();
  1505.   length += m_data.GetObjectLength();
  1506.   return length;
  1507. }
  1508.  
  1509.  
  1510. BOOL H225_NonStandardParameter::Decode(PASN_Stream & strm)
  1511. {
  1512.   if (!PreambleDecode(strm))
  1513.     return FALSE;
  1514.  
  1515.   if (!m_nonStandardIdentifier.Decode(strm))
  1516.     return FALSE;
  1517.   if (!m_data.Decode(strm))
  1518.     return FALSE;
  1519.  
  1520.   return UnknownExtensionsDecode(strm);
  1521. }
  1522.  
  1523.  
  1524. void H225_NonStandardParameter::Encode(PASN_Stream & strm) const
  1525. {
  1526.   PreambleEncode(strm);
  1527.  
  1528.   m_nonStandardIdentifier.Encode(strm);
  1529.   m_data.Encode(strm);
  1530.  
  1531.   UnknownExtensionsEncode(strm);
  1532. }
  1533.  
  1534.  
  1535. PObject * H225_NonStandardParameter::Clone() const
  1536. {
  1537. #ifndef PASN_LEANANDMEAN
  1538.   PAssert(IsClass(H225_NonStandardParameter::Class()), PInvalidCast);
  1539. #endif
  1540.   return new H225_NonStandardParameter(*this);
  1541. }
  1542.  
  1543.  
  1544. //
  1545. // PublicPartyNumber
  1546. //
  1547.  
  1548. H225_PublicPartyNumber::H225_PublicPartyNumber(unsigned tag, PASN_Object::TagClass tagClass)
  1549.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1550. {
  1551. }
  1552.  
  1553.  
  1554. #ifndef PASN_NOPRINTON
  1555. void H225_PublicPartyNumber::PrintOn(ostream & strm) const
  1556. {
  1557.   int indent = strm.precision() + 2;
  1558.   strm << "{\n";
  1559.   strm << setw(indent+21) << "publicTypeOfNumber = " << setprecision(indent) << m_publicTypeOfNumber << '\n';
  1560.   strm << setw(indent+21) << "publicNumberDigits = " << setprecision(indent) << m_publicNumberDigits << '\n';
  1561.   strm << setw(indent-1) << "}";
  1562. }
  1563. #endif
  1564.  
  1565.  
  1566. PObject::Comparison H225_PublicPartyNumber::Compare(const PObject & obj) const
  1567. {
  1568. #ifndef PASN_LEANANDMEAN
  1569.   PAssert(IsDescendant(H225_PublicPartyNumber::Class()), PInvalidCast);
  1570. #endif
  1571.   const H225_PublicPartyNumber & other = (const H225_PublicPartyNumber &)obj;
  1572.  
  1573.   Comparison result;
  1574.  
  1575.   if ((result = m_publicTypeOfNumber.Compare(other.m_publicTypeOfNumber)) != EqualTo)
  1576.     return result;
  1577.   if ((result = m_publicNumberDigits.Compare(other.m_publicNumberDigits)) != EqualTo)
  1578.     return result;
  1579.  
  1580.   return PASN_Sequence::Compare(other);
  1581. }
  1582.  
  1583.  
  1584. PINDEX H225_PublicPartyNumber::GetDataLength() const
  1585. {
  1586.   PINDEX length = 0;
  1587.   length += m_publicTypeOfNumber.GetObjectLength();
  1588.   length += m_publicNumberDigits.GetObjectLength();
  1589.   return length;
  1590. }
  1591.  
  1592.  
  1593. BOOL H225_PublicPartyNumber::Decode(PASN_Stream & strm)
  1594. {
  1595.   if (!PreambleDecode(strm))
  1596.     return FALSE;
  1597.  
  1598.   if (!m_publicTypeOfNumber.Decode(strm))
  1599.     return FALSE;
  1600.   if (!m_publicNumberDigits.Decode(strm))
  1601.     return FALSE;
  1602.  
  1603.   return UnknownExtensionsDecode(strm);
  1604. }
  1605.  
  1606.  
  1607. void H225_PublicPartyNumber::Encode(PASN_Stream & strm) const
  1608. {
  1609.   PreambleEncode(strm);
  1610.  
  1611.   m_publicTypeOfNumber.Encode(strm);
  1612.   m_publicNumberDigits.Encode(strm);
  1613.  
  1614.   UnknownExtensionsEncode(strm);
  1615. }
  1616.  
  1617.  
  1618. PObject * H225_PublicPartyNumber::Clone() const
  1619. {
  1620. #ifndef PASN_LEANANDMEAN
  1621.   PAssert(IsClass(H225_PublicPartyNumber::Class()), PInvalidCast);
  1622. #endif
  1623.   return new H225_PublicPartyNumber(*this);
  1624. }
  1625.  
  1626.  
  1627. //
  1628. // PrivatePartyNumber
  1629. //
  1630.  
  1631. H225_PrivatePartyNumber::H225_PrivatePartyNumber(unsigned tag, PASN_Object::TagClass tagClass)
  1632.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1633. {
  1634. }
  1635.  
  1636.  
  1637. #ifndef PASN_NOPRINTON
  1638. void H225_PrivatePartyNumber::PrintOn(ostream & strm) const
  1639. {
  1640.   int indent = strm.precision() + 2;
  1641.   strm << "{\n";
  1642.   strm << setw(indent+22) << "privateTypeOfNumber = " << setprecision(indent) << m_privateTypeOfNumber << '\n';
  1643.   strm << setw(indent+22) << "privateNumberDigits = " << setprecision(indent) << m_privateNumberDigits << '\n';
  1644.   strm << setw(indent-1) << "}";
  1645. }
  1646. #endif
  1647.  
  1648.  
  1649. PObject::Comparison H225_PrivatePartyNumber::Compare(const PObject & obj) const
  1650. {
  1651. #ifndef PASN_LEANANDMEAN
  1652.   PAssert(IsDescendant(H225_PrivatePartyNumber::Class()), PInvalidCast);
  1653. #endif
  1654.   const H225_PrivatePartyNumber & other = (const H225_PrivatePartyNumber &)obj;
  1655.  
  1656.   Comparison result;
  1657.  
  1658.   if ((result = m_privateTypeOfNumber.Compare(other.m_privateTypeOfNumber)) != EqualTo)
  1659.     return result;
  1660.   if ((result = m_privateNumberDigits.Compare(other.m_privateNumberDigits)) != EqualTo)
  1661.     return result;
  1662.  
  1663.   return PASN_Sequence::Compare(other);
  1664. }
  1665.  
  1666.  
  1667. PINDEX H225_PrivatePartyNumber::GetDataLength() const
  1668. {
  1669.   PINDEX length = 0;
  1670.   length += m_privateTypeOfNumber.GetObjectLength();
  1671.   length += m_privateNumberDigits.GetObjectLength();
  1672.   return length;
  1673. }
  1674.  
  1675.  
  1676. BOOL H225_PrivatePartyNumber::Decode(PASN_Stream & strm)
  1677. {
  1678.   if (!PreambleDecode(strm))
  1679.     return FALSE;
  1680.  
  1681.   if (!m_privateTypeOfNumber.Decode(strm))
  1682.     return FALSE;
  1683.   if (!m_privateNumberDigits.Decode(strm))
  1684.     return FALSE;
  1685.  
  1686.   return UnknownExtensionsDecode(strm);
  1687. }
  1688.  
  1689.  
  1690. void H225_PrivatePartyNumber::Encode(PASN_Stream & strm) const
  1691. {
  1692.   PreambleEncode(strm);
  1693.  
  1694.   m_privateTypeOfNumber.Encode(strm);
  1695.   m_privateNumberDigits.Encode(strm);
  1696.  
  1697.   UnknownExtensionsEncode(strm);
  1698. }
  1699.  
  1700.  
  1701. PObject * H225_PrivatePartyNumber::Clone() const
  1702. {
  1703. #ifndef PASN_LEANANDMEAN
  1704.   PAssert(IsClass(H225_PrivatePartyNumber::Class()), PInvalidCast);
  1705. #endif
  1706.   return new H225_PrivatePartyNumber(*this);
  1707. }
  1708.  
  1709.  
  1710. //
  1711. // ANSI-41-UIM
  1712. //
  1713.  
  1714. H225_ANSI_41_UIM::H225_ANSI_41_UIM(unsigned tag, PASN_Object::TagClass tagClass)
  1715.   : PASN_Sequence(tag, tagClass, 11, TRUE, 0)
  1716. {
  1717.   m_imsi.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  1718.   m_min.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  1719.   m_mdn.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  1720.   m_msisdn.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  1721.   m_esn.SetConstraints(PASN_Object::FixedConstraint, 16);
  1722.   m_mscid.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  1723.   m_systemMyTypeCode.SetConstraints(PASN_Object::FixedConstraint, 1);
  1724.   m_systemAccessType.SetConstraints(PASN_Object::FixedConstraint, 1);
  1725.   m_qualificationInformationCode.SetConstraints(PASN_Object::FixedConstraint, 1);
  1726.   m_sesn.SetConstraints(PASN_Object::FixedConstraint, 16);
  1727.   m_soc.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  1728. }
  1729.  
  1730.  
  1731. #ifndef PASN_NOPRINTON
  1732. void H225_ANSI_41_UIM::PrintOn(ostream & strm) const
  1733. {
  1734.   int indent = strm.precision() + 2;
  1735.   strm << "{\n";
  1736.   if (HasOptionalField(e_imsi))
  1737.     strm << setw(indent+7) << "imsi = " << setprecision(indent) << m_imsi << '\n';
  1738.   if (HasOptionalField(e_min))
  1739.     strm << setw(indent+6) << "min = " << setprecision(indent) << m_min << '\n';
  1740.   if (HasOptionalField(e_mdn))
  1741.     strm << setw(indent+6) << "mdn = " << setprecision(indent) << m_mdn << '\n';
  1742.   if (HasOptionalField(e_msisdn))
  1743.     strm << setw(indent+9) << "msisdn = " << setprecision(indent) << m_msisdn << '\n';
  1744.   if (HasOptionalField(e_esn))
  1745.     strm << setw(indent+6) << "esn = " << setprecision(indent) << m_esn << '\n';
  1746.   if (HasOptionalField(e_mscid))
  1747.     strm << setw(indent+8) << "mscid = " << setprecision(indent) << m_mscid << '\n';
  1748.   strm << setw(indent+12) << "system_id = " << setprecision(indent) << m_system_id << '\n';
  1749.   if (HasOptionalField(e_systemMyTypeCode))
  1750.     strm << setw(indent+19) << "systemMyTypeCode = " << setprecision(indent) << m_systemMyTypeCode << '\n';
  1751.   if (HasOptionalField(e_systemAccessType))
  1752.     strm << setw(indent+19) << "systemAccessType = " << setprecision(indent) << m_systemAccessType << '\n';
  1753.   if (HasOptionalField(e_qualificationInformationCode))
  1754.     strm << setw(indent+31) << "qualificationInformationCode = " << setprecision(indent) << m_qualificationInformationCode << '\n';
  1755.   if (HasOptionalField(e_sesn))
  1756.     strm << setw(indent+7) << "sesn = " << setprecision(indent) << m_sesn << '\n';
  1757.   if (HasOptionalField(e_soc))
  1758.     strm << setw(indent+6) << "soc = " << setprecision(indent) << m_soc << '\n';
  1759.   strm << setw(indent-1) << "}";
  1760. }
  1761. #endif
  1762.  
  1763.  
  1764. PObject::Comparison H225_ANSI_41_UIM::Compare(const PObject & obj) const
  1765. {
  1766. #ifndef PASN_LEANANDMEAN
  1767.   PAssert(IsDescendant(H225_ANSI_41_UIM::Class()), PInvalidCast);
  1768. #endif
  1769.   const H225_ANSI_41_UIM & other = (const H225_ANSI_41_UIM &)obj;
  1770.  
  1771.   Comparison result;
  1772.  
  1773.   if ((result = m_imsi.Compare(other.m_imsi)) != EqualTo)
  1774.     return result;
  1775.   if ((result = m_min.Compare(other.m_min)) != EqualTo)
  1776.     return result;
  1777.   if ((result = m_mdn.Compare(other.m_mdn)) != EqualTo)
  1778.     return result;
  1779.   if ((result = m_msisdn.Compare(other.m_msisdn)) != EqualTo)
  1780.     return result;
  1781.   if ((result = m_esn.Compare(other.m_esn)) != EqualTo)
  1782.     return result;
  1783.   if ((result = m_mscid.Compare(other.m_mscid)) != EqualTo)
  1784.     return result;
  1785.   if ((result = m_system_id.Compare(other.m_system_id)) != EqualTo)
  1786.     return result;
  1787.   if ((result = m_systemMyTypeCode.Compare(other.m_systemMyTypeCode)) != EqualTo)
  1788.     return result;
  1789.   if ((result = m_systemAccessType.Compare(other.m_systemAccessType)) != EqualTo)
  1790.     return result;
  1791.   if ((result = m_qualificationInformationCode.Compare(other.m_qualificationInformationCode)) != EqualTo)
  1792.     return result;
  1793.   if ((result = m_sesn.Compare(other.m_sesn)) != EqualTo)
  1794.     return result;
  1795.   if ((result = m_soc.Compare(other.m_soc)) != EqualTo)
  1796.     return result;
  1797.  
  1798.   return PASN_Sequence::Compare(other);
  1799. }
  1800.  
  1801.  
  1802. PINDEX H225_ANSI_41_UIM::GetDataLength() const
  1803. {
  1804.   PINDEX length = 0;
  1805.   if (HasOptionalField(e_imsi))
  1806.     length += m_imsi.GetObjectLength();
  1807.   if (HasOptionalField(e_min))
  1808.     length += m_min.GetObjectLength();
  1809.   if (HasOptionalField(e_mdn))
  1810.     length += m_mdn.GetObjectLength();
  1811.   if (HasOptionalField(e_msisdn))
  1812.     length += m_msisdn.GetObjectLength();
  1813.   if (HasOptionalField(e_esn))
  1814.     length += m_esn.GetObjectLength();
  1815.   if (HasOptionalField(e_mscid))
  1816.     length += m_mscid.GetObjectLength();
  1817.   length += m_system_id.GetObjectLength();
  1818.   if (HasOptionalField(e_systemMyTypeCode))
  1819.     length += m_systemMyTypeCode.GetObjectLength();
  1820.   if (HasOptionalField(e_systemAccessType))
  1821.     length += m_systemAccessType.GetObjectLength();
  1822.   if (HasOptionalField(e_qualificationInformationCode))
  1823.     length += m_qualificationInformationCode.GetObjectLength();
  1824.   if (HasOptionalField(e_sesn))
  1825.     length += m_sesn.GetObjectLength();
  1826.   if (HasOptionalField(e_soc))
  1827.     length += m_soc.GetObjectLength();
  1828.   return length;
  1829. }
  1830.  
  1831.  
  1832. BOOL H225_ANSI_41_UIM::Decode(PASN_Stream & strm)
  1833. {
  1834.   if (!PreambleDecode(strm))
  1835.     return FALSE;
  1836.  
  1837.   if (HasOptionalField(e_imsi) && !m_imsi.Decode(strm))
  1838.     return FALSE;
  1839.   if (HasOptionalField(e_min) && !m_min.Decode(strm))
  1840.     return FALSE;
  1841.   if (HasOptionalField(e_mdn) && !m_mdn.Decode(strm))
  1842.     return FALSE;
  1843.   if (HasOptionalField(e_msisdn) && !m_msisdn.Decode(strm))
  1844.     return FALSE;
  1845.   if (HasOptionalField(e_esn) && !m_esn.Decode(strm))
  1846.     return FALSE;
  1847.   if (HasOptionalField(e_mscid) && !m_mscid.Decode(strm))
  1848.     return FALSE;
  1849.   if (!m_system_id.Decode(strm))
  1850.     return FALSE;
  1851.   if (HasOptionalField(e_systemMyTypeCode) && !m_systemMyTypeCode.Decode(strm))
  1852.     return FALSE;
  1853.   if (HasOptionalField(e_systemAccessType) && !m_systemAccessType.Decode(strm))
  1854.     return FALSE;
  1855.   if (HasOptionalField(e_qualificationInformationCode) && !m_qualificationInformationCode.Decode(strm))
  1856.     return FALSE;
  1857.   if (HasOptionalField(e_sesn) && !m_sesn.Decode(strm))
  1858.     return FALSE;
  1859.   if (HasOptionalField(e_soc) && !m_soc.Decode(strm))
  1860.     return FALSE;
  1861.  
  1862.   return UnknownExtensionsDecode(strm);
  1863. }
  1864.  
  1865.  
  1866. void H225_ANSI_41_UIM::Encode(PASN_Stream & strm) const
  1867. {
  1868.   PreambleEncode(strm);
  1869.  
  1870.   if (HasOptionalField(e_imsi))
  1871.     m_imsi.Encode(strm);
  1872.   if (HasOptionalField(e_min))
  1873.     m_min.Encode(strm);
  1874.   if (HasOptionalField(e_mdn))
  1875.     m_mdn.Encode(strm);
  1876.   if (HasOptionalField(e_msisdn))
  1877.     m_msisdn.Encode(strm);
  1878.   if (HasOptionalField(e_esn))
  1879.     m_esn.Encode(strm);
  1880.   if (HasOptionalField(e_mscid))
  1881.     m_mscid.Encode(strm);
  1882.   m_system_id.Encode(strm);
  1883.   if (HasOptionalField(e_systemMyTypeCode))
  1884.     m_systemMyTypeCode.Encode(strm);
  1885.   if (HasOptionalField(e_systemAccessType))
  1886.     m_systemAccessType.Encode(strm);
  1887.   if (HasOptionalField(e_qualificationInformationCode))
  1888.     m_qualificationInformationCode.Encode(strm);
  1889.   if (HasOptionalField(e_sesn))
  1890.     m_sesn.Encode(strm);
  1891.   if (HasOptionalField(e_soc))
  1892.     m_soc.Encode(strm);
  1893.  
  1894.   UnknownExtensionsEncode(strm);
  1895. }
  1896.  
  1897.  
  1898. PObject * H225_ANSI_41_UIM::Clone() const
  1899. {
  1900. #ifndef PASN_LEANANDMEAN
  1901.   PAssert(IsClass(H225_ANSI_41_UIM::Class()), PInvalidCast);
  1902. #endif
  1903.   return new H225_ANSI_41_UIM(*this);
  1904. }
  1905.  
  1906.  
  1907. //
  1908. // AlternateTransportAddresses
  1909. //
  1910.  
  1911. H225_AlternateTransportAddresses::H225_AlternateTransportAddresses(unsigned tag, PASN_Object::TagClass tagClass)
  1912.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  1913. {
  1914. }
  1915.  
  1916.  
  1917. #ifndef PASN_NOPRINTON
  1918. void H225_AlternateTransportAddresses::PrintOn(ostream & strm) const
  1919. {
  1920.   int indent = strm.precision() + 2;
  1921.   strm << "{\n";
  1922.   if (HasOptionalField(e_annexE))
  1923.     strm << setw(indent+9) << "annexE = " << setprecision(indent) << m_annexE << '\n';
  1924.   strm << setw(indent-1) << "}";
  1925. }
  1926. #endif
  1927.  
  1928.  
  1929. PObject::Comparison H225_AlternateTransportAddresses::Compare(const PObject & obj) const
  1930. {
  1931. #ifndef PASN_LEANANDMEAN
  1932.   PAssert(IsDescendant(H225_AlternateTransportAddresses::Class()), PInvalidCast);
  1933. #endif
  1934.   const H225_AlternateTransportAddresses & other = (const H225_AlternateTransportAddresses &)obj;
  1935.  
  1936.   Comparison result;
  1937.  
  1938.   if ((result = m_annexE.Compare(other.m_annexE)) != EqualTo)
  1939.     return result;
  1940.  
  1941.   return PASN_Sequence::Compare(other);
  1942. }
  1943.  
  1944.  
  1945. PINDEX H225_AlternateTransportAddresses::GetDataLength() const
  1946. {
  1947.   PINDEX length = 0;
  1948.   if (HasOptionalField(e_annexE))
  1949.     length += m_annexE.GetObjectLength();
  1950.   return length;
  1951. }
  1952.  
  1953.  
  1954. BOOL H225_AlternateTransportAddresses::Decode(PASN_Stream & strm)
  1955. {
  1956.   if (!PreambleDecode(strm))
  1957.     return FALSE;
  1958.  
  1959.   if (HasOptionalField(e_annexE) && !m_annexE.Decode(strm))
  1960.     return FALSE;
  1961.  
  1962.   return UnknownExtensionsDecode(strm);
  1963. }
  1964.  
  1965.  
  1966. void H225_AlternateTransportAddresses::Encode(PASN_Stream & strm) const
  1967. {
  1968.   PreambleEncode(strm);
  1969.  
  1970.   if (HasOptionalField(e_annexE))
  1971.     m_annexE.Encode(strm);
  1972.  
  1973.   UnknownExtensionsEncode(strm);
  1974. }
  1975.  
  1976.  
  1977. PObject * H225_AlternateTransportAddresses::Clone() const
  1978. {
  1979. #ifndef PASN_LEANANDMEAN
  1980.   PAssert(IsClass(H225_AlternateTransportAddresses::Class()), PInvalidCast);
  1981. #endif
  1982.   return new H225_AlternateTransportAddresses(*this);
  1983. }
  1984.  
  1985.  
  1986. //
  1987. // AlternateGK
  1988. //
  1989.  
  1990. H225_AlternateGK::H225_AlternateGK(unsigned tag, PASN_Object::TagClass tagClass)
  1991.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  1992. {
  1993.   m_priority.SetConstraints(PASN_Object::FixedConstraint, 0, 127);
  1994. }
  1995.  
  1996.  
  1997. #ifndef PASN_NOPRINTON
  1998. void H225_AlternateGK::PrintOn(ostream & strm) const
  1999. {
  2000.   int indent = strm.precision() + 2;
  2001.   strm << "{\n";
  2002.   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
  2003.   if (HasOptionalField(e_gatekeeperIdentifier))
  2004.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  2005.   strm << setw(indent+17) << "needToRegister = " << setprecision(indent) << m_needToRegister << '\n';
  2006.   strm << setw(indent+11) << "priority = " << setprecision(indent) << m_priority << '\n';
  2007.   strm << setw(indent-1) << "}";
  2008. }
  2009. #endif
  2010.  
  2011.  
  2012. PObject::Comparison H225_AlternateGK::Compare(const PObject & obj) const
  2013. {
  2014. #ifndef PASN_LEANANDMEAN
  2015.   PAssert(IsDescendant(H225_AlternateGK::Class()), PInvalidCast);
  2016. #endif
  2017.   const H225_AlternateGK & other = (const H225_AlternateGK &)obj;
  2018.  
  2019.   Comparison result;
  2020.  
  2021.   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
  2022.     return result;
  2023.   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
  2024.     return result;
  2025.   if ((result = m_needToRegister.Compare(other.m_needToRegister)) != EqualTo)
  2026.     return result;
  2027.   if ((result = m_priority.Compare(other.m_priority)) != EqualTo)
  2028.     return result;
  2029.  
  2030.   return PASN_Sequence::Compare(other);
  2031. }
  2032.  
  2033.  
  2034. PINDEX H225_AlternateGK::GetDataLength() const
  2035. {
  2036.   PINDEX length = 0;
  2037.   length += m_rasAddress.GetObjectLength();
  2038.   if (HasOptionalField(e_gatekeeperIdentifier))
  2039.     length += m_gatekeeperIdentifier.GetObjectLength();
  2040.   length += m_needToRegister.GetObjectLength();
  2041.   length += m_priority.GetObjectLength();
  2042.   return length;
  2043. }
  2044.  
  2045.  
  2046. BOOL H225_AlternateGK::Decode(PASN_Stream & strm)
  2047. {
  2048.   if (!PreambleDecode(strm))
  2049.     return FALSE;
  2050.  
  2051.   if (!m_rasAddress.Decode(strm))
  2052.     return FALSE;
  2053.   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
  2054.     return FALSE;
  2055.   if (!m_needToRegister.Decode(strm))
  2056.     return FALSE;
  2057.   if (!m_priority.Decode(strm))
  2058.     return FALSE;
  2059.  
  2060.   return UnknownExtensionsDecode(strm);
  2061. }
  2062.  
  2063.  
  2064. void H225_AlternateGK::Encode(PASN_Stream & strm) const
  2065. {
  2066.   PreambleEncode(strm);
  2067.  
  2068.   m_rasAddress.Encode(strm);
  2069.   if (HasOptionalField(e_gatekeeperIdentifier))
  2070.     m_gatekeeperIdentifier.Encode(strm);
  2071.   m_needToRegister.Encode(strm);
  2072.   m_priority.Encode(strm);
  2073.  
  2074.   UnknownExtensionsEncode(strm);
  2075. }
  2076.  
  2077.  
  2078. PObject * H225_AlternateGK::Clone() const
  2079. {
  2080. #ifndef PASN_LEANANDMEAN
  2081.   PAssert(IsClass(H225_AlternateGK::Class()), PInvalidCast);
  2082. #endif
  2083.   return new H225_AlternateGK(*this);
  2084. }
  2085.  
  2086.  
  2087. //
  2088. // AltGKInfo
  2089. //
  2090.  
  2091. H225_AltGKInfo::H225_AltGKInfo(unsigned tag, PASN_Object::TagClass tagClass)
  2092.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  2093. {
  2094. }
  2095.  
  2096.  
  2097. #ifndef PASN_NOPRINTON
  2098. void H225_AltGKInfo::PrintOn(ostream & strm) const
  2099. {
  2100.   int indent = strm.precision() + 2;
  2101.   strm << "{\n";
  2102.   strm << setw(indent+22) << "alternateGatekeeper = " << setprecision(indent) << m_alternateGatekeeper << '\n';
  2103.   strm << setw(indent+19) << "altGKisPermanent = " << setprecision(indent) << m_altGKisPermanent << '\n';
  2104.   strm << setw(indent-1) << "}";
  2105. }
  2106. #endif
  2107.  
  2108.  
  2109. PObject::Comparison H225_AltGKInfo::Compare(const PObject & obj) const
  2110. {
  2111. #ifndef PASN_LEANANDMEAN
  2112.   PAssert(IsDescendant(H225_AltGKInfo::Class()), PInvalidCast);
  2113. #endif
  2114.   const H225_AltGKInfo & other = (const H225_AltGKInfo &)obj;
  2115.  
  2116.   Comparison result;
  2117.  
  2118.   if ((result = m_alternateGatekeeper.Compare(other.m_alternateGatekeeper)) != EqualTo)
  2119.     return result;
  2120.   if ((result = m_altGKisPermanent.Compare(other.m_altGKisPermanent)) != EqualTo)
  2121.     return result;
  2122.  
  2123.   return PASN_Sequence::Compare(other);
  2124. }
  2125.  
  2126.  
  2127. PINDEX H225_AltGKInfo::GetDataLength() const
  2128. {
  2129.   PINDEX length = 0;
  2130.   length += m_alternateGatekeeper.GetObjectLength();
  2131.   length += m_altGKisPermanent.GetObjectLength();
  2132.   return length;
  2133. }
  2134.  
  2135.  
  2136. BOOL H225_AltGKInfo::Decode(PASN_Stream & strm)
  2137. {
  2138.   if (!PreambleDecode(strm))
  2139.     return FALSE;
  2140.  
  2141.   if (!m_alternateGatekeeper.Decode(strm))
  2142.     return FALSE;
  2143.   if (!m_altGKisPermanent.Decode(strm))
  2144.     return FALSE;
  2145.  
  2146.   return UnknownExtensionsDecode(strm);
  2147. }
  2148.  
  2149.  
  2150. void H225_AltGKInfo::Encode(PASN_Stream & strm) const
  2151. {
  2152.   PreambleEncode(strm);
  2153.  
  2154.   m_alternateGatekeeper.Encode(strm);
  2155.   m_altGKisPermanent.Encode(strm);
  2156.  
  2157.   UnknownExtensionsEncode(strm);
  2158. }
  2159.  
  2160.  
  2161. PObject * H225_AltGKInfo::Clone() const
  2162. {
  2163. #ifndef PASN_LEANANDMEAN
  2164.   PAssert(IsClass(H225_AltGKInfo::Class()), PInvalidCast);
  2165. #endif
  2166.   return new H225_AltGKInfo(*this);
  2167. }
  2168.  
  2169.  
  2170. //
  2171. // SecurityCapabilities
  2172. //
  2173.  
  2174. H225_SecurityCapabilities::H225_SecurityCapabilities(unsigned tag, PASN_Object::TagClass tagClass)
  2175.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  2176. {
  2177. }
  2178.  
  2179.  
  2180. #ifndef PASN_NOPRINTON
  2181. void H225_SecurityCapabilities::PrintOn(ostream & strm) const
  2182. {
  2183.   int indent = strm.precision() + 2;
  2184.   strm << "{\n";
  2185.   if (HasOptionalField(e_nonStandard))
  2186.     strm << setw(indent+14) << "nonStandard = " << setprecision(indent) << m_nonStandard << '\n';
  2187.   strm << setw(indent+13) << "encryption = " << setprecision(indent) << m_encryption << '\n';
  2188.   strm << setw(indent+16) << "authenticaton = " << setprecision(indent) << m_authenticaton << '\n';
  2189.   strm << setw(indent+12) << "integrity = " << setprecision(indent) << m_integrity << '\n';
  2190.   strm << setw(indent-1) << "}";
  2191. }
  2192. #endif
  2193.  
  2194.  
  2195. PObject::Comparison H225_SecurityCapabilities::Compare(const PObject & obj) const
  2196. {
  2197. #ifndef PASN_LEANANDMEAN
  2198.   PAssert(IsDescendant(H225_SecurityCapabilities::Class()), PInvalidCast);
  2199. #endif
  2200.   const H225_SecurityCapabilities & other = (const H225_SecurityCapabilities &)obj;
  2201.  
  2202.   Comparison result;
  2203.  
  2204.   if ((result = m_nonStandard.Compare(other.m_nonStandard)) != EqualTo)
  2205.     return result;
  2206.   if ((result = m_encryption.Compare(other.m_encryption)) != EqualTo)
  2207.     return result;
  2208.   if ((result = m_authenticaton.Compare(other.m_authenticaton)) != EqualTo)
  2209.     return result;
  2210.   if ((result = m_integrity.Compare(other.m_integrity)) != EqualTo)
  2211.     return result;
  2212.  
  2213.   return PASN_Sequence::Compare(other);
  2214. }
  2215.  
  2216.  
  2217. PINDEX H225_SecurityCapabilities::GetDataLength() const
  2218. {
  2219.   PINDEX length = 0;
  2220.   if (HasOptionalField(e_nonStandard))
  2221.     length += m_nonStandard.GetObjectLength();
  2222.   length += m_encryption.GetObjectLength();
  2223.   length += m_authenticaton.GetObjectLength();
  2224.   length += m_integrity.GetObjectLength();
  2225.   return length;
  2226. }
  2227.  
  2228.  
  2229. BOOL H225_SecurityCapabilities::Decode(PASN_Stream & strm)
  2230. {
  2231.   if (!PreambleDecode(strm))
  2232.     return FALSE;
  2233.  
  2234.   if (HasOptionalField(e_nonStandard) && !m_nonStandard.Decode(strm))
  2235.     return FALSE;
  2236.   if (!m_encryption.Decode(strm))
  2237.     return FALSE;
  2238.   if (!m_authenticaton.Decode(strm))
  2239.     return FALSE;
  2240.   if (!m_integrity.Decode(strm))
  2241.     return FALSE;
  2242.  
  2243.   return UnknownExtensionsDecode(strm);
  2244. }
  2245.  
  2246.  
  2247. void H225_SecurityCapabilities::Encode(PASN_Stream & strm) const
  2248. {
  2249.   PreambleEncode(strm);
  2250.  
  2251.   if (HasOptionalField(e_nonStandard))
  2252.     m_nonStandard.Encode(strm);
  2253.   m_encryption.Encode(strm);
  2254.   m_authenticaton.Encode(strm);
  2255.   m_integrity.Encode(strm);
  2256.  
  2257.   UnknownExtensionsEncode(strm);
  2258. }
  2259.  
  2260.  
  2261. PObject * H225_SecurityCapabilities::Clone() const
  2262. {
  2263. #ifndef PASN_LEANANDMEAN
  2264.   PAssert(IsClass(H225_SecurityCapabilities::Class()), PInvalidCast);
  2265. #endif
  2266.   return new H225_SecurityCapabilities(*this);
  2267. }
  2268.  
  2269.  
  2270. //
  2271. // QseriesOptions
  2272. //
  2273.  
  2274. H225_QseriesOptions::H225_QseriesOptions(unsigned tag, PASN_Object::TagClass tagClass)
  2275.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  2276. {
  2277. }
  2278.  
  2279.  
  2280. #ifndef PASN_NOPRINTON
  2281. void H225_QseriesOptions::PrintOn(ostream & strm) const
  2282. {
  2283.   int indent = strm.precision() + 2;
  2284.   strm << "{\n";
  2285.   strm << setw(indent+11) << "q932Full = " << setprecision(indent) << m_q932Full << '\n';
  2286.   strm << setw(indent+11) << "q951Full = " << setprecision(indent) << m_q951Full << '\n';
  2287.   strm << setw(indent+11) << "q952Full = " << setprecision(indent) << m_q952Full << '\n';
  2288.   strm << setw(indent+11) << "q953Full = " << setprecision(indent) << m_q953Full << '\n';
  2289.   strm << setw(indent+11) << "q955Full = " << setprecision(indent) << m_q955Full << '\n';
  2290.   strm << setw(indent+11) << "q956Full = " << setprecision(indent) << m_q956Full << '\n';
  2291.   strm << setw(indent+11) << "q957Full = " << setprecision(indent) << m_q957Full << '\n';
  2292.   strm << setw(indent+11) << "q954Info = " << setprecision(indent) << m_q954Info << '\n';
  2293.   strm << setw(indent-1) << "}";
  2294. }
  2295. #endif
  2296.  
  2297.  
  2298. PObject::Comparison H225_QseriesOptions::Compare(const PObject & obj) const
  2299. {
  2300. #ifndef PASN_LEANANDMEAN
  2301.   PAssert(IsDescendant(H225_QseriesOptions::Class()), PInvalidCast);
  2302. #endif
  2303.   const H225_QseriesOptions & other = (const H225_QseriesOptions &)obj;
  2304.  
  2305.   Comparison result;
  2306.  
  2307.   if ((result = m_q932Full.Compare(other.m_q932Full)) != EqualTo)
  2308.     return result;
  2309.   if ((result = m_q951Full.Compare(other.m_q951Full)) != EqualTo)
  2310.     return result;
  2311.   if ((result = m_q952Full.Compare(other.m_q952Full)) != EqualTo)
  2312.     return result;
  2313.   if ((result = m_q953Full.Compare(other.m_q953Full)) != EqualTo)
  2314.     return result;
  2315.   if ((result = m_q955Full.Compare(other.m_q955Full)) != EqualTo)
  2316.     return result;
  2317.   if ((result = m_q956Full.Compare(other.m_q956Full)) != EqualTo)
  2318.     return result;
  2319.   if ((result = m_q957Full.Compare(other.m_q957Full)) != EqualTo)
  2320.     return result;
  2321.   if ((result = m_q954Info.Compare(other.m_q954Info)) != EqualTo)
  2322.     return result;
  2323.  
  2324.   return PASN_Sequence::Compare(other);
  2325. }
  2326.  
  2327.  
  2328. PINDEX H225_QseriesOptions::GetDataLength() const
  2329. {
  2330.   PINDEX length = 0;
  2331.   length += m_q932Full.GetObjectLength();
  2332.   length += m_q951Full.GetObjectLength();
  2333.   length += m_q952Full.GetObjectLength();
  2334.   length += m_q953Full.GetObjectLength();
  2335.   length += m_q955Full.GetObjectLength();
  2336.   length += m_q956Full.GetObjectLength();
  2337.   length += m_q957Full.GetObjectLength();
  2338.   length += m_q954Info.GetObjectLength();
  2339.   return length;
  2340. }
  2341.  
  2342.  
  2343. BOOL H225_QseriesOptions::Decode(PASN_Stream & strm)
  2344. {
  2345.   if (!PreambleDecode(strm))
  2346.     return FALSE;
  2347.  
  2348.   if (!m_q932Full.Decode(strm))
  2349.     return FALSE;
  2350.   if (!m_q951Full.Decode(strm))
  2351.     return FALSE;
  2352.   if (!m_q952Full.Decode(strm))
  2353.     return FALSE;
  2354.   if (!m_q953Full.Decode(strm))
  2355.     return FALSE;
  2356.   if (!m_q955Full.Decode(strm))
  2357.     return FALSE;
  2358.   if (!m_q956Full.Decode(strm))
  2359.     return FALSE;
  2360.   if (!m_q957Full.Decode(strm))
  2361.     return FALSE;
  2362.   if (!m_q954Info.Decode(strm))
  2363.     return FALSE;
  2364.  
  2365.   return UnknownExtensionsDecode(strm);
  2366. }
  2367.  
  2368.  
  2369. void H225_QseriesOptions::Encode(PASN_Stream & strm) const
  2370. {
  2371.   PreambleEncode(strm);
  2372.  
  2373.   m_q932Full.Encode(strm);
  2374.   m_q951Full.Encode(strm);
  2375.   m_q952Full.Encode(strm);
  2376.   m_q953Full.Encode(strm);
  2377.   m_q955Full.Encode(strm);
  2378.   m_q956Full.Encode(strm);
  2379.   m_q957Full.Encode(strm);
  2380.   m_q954Info.Encode(strm);
  2381.  
  2382.   UnknownExtensionsEncode(strm);
  2383. }
  2384.  
  2385.  
  2386. PObject * H225_QseriesOptions::Clone() const
  2387. {
  2388. #ifndef PASN_LEANANDMEAN
  2389.   PAssert(IsClass(H225_QseriesOptions::Class()), PInvalidCast);
  2390. #endif
  2391.   return new H225_QseriesOptions(*this);
  2392. }
  2393.  
  2394.  
  2395. //
  2396. // DataRate
  2397. //
  2398.  
  2399. H225_DataRate::H225_DataRate(unsigned tag, PASN_Object::TagClass tagClass)
  2400.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  2401. {
  2402.   m_channelMultiplier.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  2403. }
  2404.  
  2405.  
  2406. #ifndef PASN_NOPRINTON
  2407. void H225_DataRate::PrintOn(ostream & strm) const
  2408. {
  2409.   int indent = strm.precision() + 2;
  2410.   strm << "{\n";
  2411.   if (HasOptionalField(e_nonStandardData))
  2412.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  2413.   strm << setw(indent+14) << "channelRate = " << setprecision(indent) << m_channelRate << '\n';
  2414.   if (HasOptionalField(e_channelMultiplier))
  2415.     strm << setw(indent+20) << "channelMultiplier = " << setprecision(indent) << m_channelMultiplier << '\n';
  2416.   strm << setw(indent-1) << "}";
  2417. }
  2418. #endif
  2419.  
  2420.  
  2421. PObject::Comparison H225_DataRate::Compare(const PObject & obj) const
  2422. {
  2423. #ifndef PASN_LEANANDMEAN
  2424.   PAssert(IsDescendant(H225_DataRate::Class()), PInvalidCast);
  2425. #endif
  2426.   const H225_DataRate & other = (const H225_DataRate &)obj;
  2427.  
  2428.   Comparison result;
  2429.  
  2430.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  2431.     return result;
  2432.   if ((result = m_channelRate.Compare(other.m_channelRate)) != EqualTo)
  2433.     return result;
  2434.   if ((result = m_channelMultiplier.Compare(other.m_channelMultiplier)) != EqualTo)
  2435.     return result;
  2436.  
  2437.   return PASN_Sequence::Compare(other);
  2438. }
  2439.  
  2440.  
  2441. PINDEX H225_DataRate::GetDataLength() const
  2442. {
  2443.   PINDEX length = 0;
  2444.   if (HasOptionalField(e_nonStandardData))
  2445.     length += m_nonStandardData.GetObjectLength();
  2446.   length += m_channelRate.GetObjectLength();
  2447.   if (HasOptionalField(e_channelMultiplier))
  2448.     length += m_channelMultiplier.GetObjectLength();
  2449.   return length;
  2450. }
  2451.  
  2452.  
  2453. BOOL H225_DataRate::Decode(PASN_Stream & strm)
  2454. {
  2455.   if (!PreambleDecode(strm))
  2456.     return FALSE;
  2457.  
  2458.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  2459.     return FALSE;
  2460.   if (!m_channelRate.Decode(strm))
  2461.     return FALSE;
  2462.   if (HasOptionalField(e_channelMultiplier) && !m_channelMultiplier.Decode(strm))
  2463.     return FALSE;
  2464.  
  2465.   return UnknownExtensionsDecode(strm);
  2466. }
  2467.  
  2468.  
  2469. void H225_DataRate::Encode(PASN_Stream & strm) const
  2470. {
  2471.   PreambleEncode(strm);
  2472.  
  2473.   if (HasOptionalField(e_nonStandardData))
  2474.     m_nonStandardData.Encode(strm);
  2475.   m_channelRate.Encode(strm);
  2476.   if (HasOptionalField(e_channelMultiplier))
  2477.     m_channelMultiplier.Encode(strm);
  2478.  
  2479.   UnknownExtensionsEncode(strm);
  2480. }
  2481.  
  2482.  
  2483. PObject * H225_DataRate::Clone() const
  2484. {
  2485. #ifndef PASN_LEANANDMEAN
  2486.   PAssert(IsClass(H225_DataRate::Class()), PInvalidCast);
  2487. #endif
  2488.   return new H225_DataRate(*this);
  2489. }
  2490.  
  2491.  
  2492. //
  2493. // SupportedPrefix
  2494. //
  2495.  
  2496. H225_SupportedPrefix::H225_SupportedPrefix(unsigned tag, PASN_Object::TagClass tagClass)
  2497.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  2498. {
  2499. }
  2500.  
  2501.  
  2502. #ifndef PASN_NOPRINTON
  2503. void H225_SupportedPrefix::PrintOn(ostream & strm) const
  2504. {
  2505.   int indent = strm.precision() + 2;
  2506.   strm << "{\n";
  2507.   if (HasOptionalField(e_nonStandardData))
  2508.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  2509.   strm << setw(indent+9) << "prefix = " << setprecision(indent) << m_prefix << '\n';
  2510.   strm << setw(indent-1) << "}";
  2511. }
  2512. #endif
  2513.  
  2514.  
  2515. PObject::Comparison H225_SupportedPrefix::Compare(const PObject & obj) const
  2516. {
  2517. #ifndef PASN_LEANANDMEAN
  2518.   PAssert(IsDescendant(H225_SupportedPrefix::Class()), PInvalidCast);
  2519. #endif
  2520.   const H225_SupportedPrefix & other = (const H225_SupportedPrefix &)obj;
  2521.  
  2522.   Comparison result;
  2523.  
  2524.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  2525.     return result;
  2526.   if ((result = m_prefix.Compare(other.m_prefix)) != EqualTo)
  2527.     return result;
  2528.  
  2529.   return PASN_Sequence::Compare(other);
  2530. }
  2531.  
  2532.  
  2533. PINDEX H225_SupportedPrefix::GetDataLength() const
  2534. {
  2535.   PINDEX length = 0;
  2536.   if (HasOptionalField(e_nonStandardData))
  2537.     length += m_nonStandardData.GetObjectLength();
  2538.   length += m_prefix.GetObjectLength();
  2539.   return length;
  2540. }
  2541.  
  2542.  
  2543. BOOL H225_SupportedPrefix::Decode(PASN_Stream & strm)
  2544. {
  2545.   if (!PreambleDecode(strm))
  2546.     return FALSE;
  2547.  
  2548.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  2549.     return FALSE;
  2550.   if (!m_prefix.Decode(strm))
  2551.     return FALSE;
  2552.  
  2553.   return UnknownExtensionsDecode(strm);
  2554. }
  2555.  
  2556.  
  2557. void H225_SupportedPrefix::Encode(PASN_Stream & strm) const
  2558. {
  2559.   PreambleEncode(strm);
  2560.  
  2561.   if (HasOptionalField(e_nonStandardData))
  2562.     m_nonStandardData.Encode(strm);
  2563.   m_prefix.Encode(strm);
  2564.  
  2565.   UnknownExtensionsEncode(strm);
  2566. }
  2567.  
  2568.  
  2569. PObject * H225_SupportedPrefix::Clone() const
  2570. {
  2571. #ifndef PASN_LEANANDMEAN
  2572.   PAssert(IsClass(H225_SupportedPrefix::Class()), PInvalidCast);
  2573. #endif
  2574.   return new H225_SupportedPrefix(*this);
  2575. }
  2576.  
  2577.  
  2578. //
  2579. // CapacityReportingSpecification
  2580. //
  2581.  
  2582. H225_CapacityReportingSpecification::H225_CapacityReportingSpecification(unsigned tag, PASN_Object::TagClass tagClass)
  2583.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  2584. {
  2585. }
  2586.  
  2587.  
  2588. #ifndef PASN_NOPRINTON
  2589. void H225_CapacityReportingSpecification::PrintOn(ostream & strm) const
  2590. {
  2591.   int indent = strm.precision() + 2;
  2592.   strm << "{\n";
  2593.   strm << setw(indent+7) << "when = " << setprecision(indent) << m_when << '\n';
  2594.   strm << setw(indent-1) << "}";
  2595. }
  2596. #endif
  2597.  
  2598.  
  2599. PObject::Comparison H225_CapacityReportingSpecification::Compare(const PObject & obj) const
  2600. {
  2601. #ifndef PASN_LEANANDMEAN
  2602.   PAssert(IsDescendant(H225_CapacityReportingSpecification::Class()), PInvalidCast);
  2603. #endif
  2604.   const H225_CapacityReportingSpecification & other = (const H225_CapacityReportingSpecification &)obj;
  2605.  
  2606.   Comparison result;
  2607.  
  2608.   if ((result = m_when.Compare(other.m_when)) != EqualTo)
  2609.     return result;
  2610.  
  2611.   return PASN_Sequence::Compare(other);
  2612. }
  2613.  
  2614.  
  2615. PINDEX H225_CapacityReportingSpecification::GetDataLength() const
  2616. {
  2617.   PINDEX length = 0;
  2618.   length += m_when.GetObjectLength();
  2619.   return length;
  2620. }
  2621.  
  2622.  
  2623. BOOL H225_CapacityReportingSpecification::Decode(PASN_Stream & strm)
  2624. {
  2625.   if (!PreambleDecode(strm))
  2626.     return FALSE;
  2627.  
  2628.   if (!m_when.Decode(strm))
  2629.     return FALSE;
  2630.  
  2631.   return UnknownExtensionsDecode(strm);
  2632. }
  2633.  
  2634.  
  2635. void H225_CapacityReportingSpecification::Encode(PASN_Stream & strm) const
  2636. {
  2637.   PreambleEncode(strm);
  2638.  
  2639.   m_when.Encode(strm);
  2640.  
  2641.   UnknownExtensionsEncode(strm);
  2642. }
  2643.  
  2644.  
  2645. PObject * H225_CapacityReportingSpecification::Clone() const
  2646. {
  2647. #ifndef PASN_LEANANDMEAN
  2648.   PAssert(IsClass(H225_CapacityReportingSpecification::Class()), PInvalidCast);
  2649. #endif
  2650.   return new H225_CapacityReportingSpecification(*this);
  2651. }
  2652.  
  2653.  
  2654. //
  2655. // CallCapacityInfo
  2656. //
  2657.  
  2658. H225_CallCapacityInfo::H225_CallCapacityInfo(unsigned tag, PASN_Object::TagClass tagClass)
  2659.   : PASN_Sequence(tag, tagClass, 11, TRUE, 0)
  2660. {
  2661. }
  2662.  
  2663.  
  2664. #ifndef PASN_NOPRINTON
  2665. void H225_CallCapacityInfo::PrintOn(ostream & strm) const
  2666. {
  2667.   int indent = strm.precision() + 2;
  2668.   strm << "{\n";
  2669.   if (HasOptionalField(e_voiceGwCallsAvailable))
  2670.     strm << setw(indent+24) << "voiceGwCallsAvailable = " << setprecision(indent) << m_voiceGwCallsAvailable << '\n';
  2671.   if (HasOptionalField(e_h310GwCallsAvailable))
  2672.     strm << setw(indent+23) << "h310GwCallsAvailable = " << setprecision(indent) << m_h310GwCallsAvailable << '\n';
  2673.   if (HasOptionalField(e_h320GwCallsAvailable))
  2674.     strm << setw(indent+23) << "h320GwCallsAvailable = " << setprecision(indent) << m_h320GwCallsAvailable << '\n';
  2675.   if (HasOptionalField(e_h321GwCallsAvailable))
  2676.     strm << setw(indent+23) << "h321GwCallsAvailable = " << setprecision(indent) << m_h321GwCallsAvailable << '\n';
  2677.   if (HasOptionalField(e_h322GwCallsAvailable))
  2678.     strm << setw(indent+23) << "h322GwCallsAvailable = " << setprecision(indent) << m_h322GwCallsAvailable << '\n';
  2679.   if (HasOptionalField(e_h323GwCallsAvailable))
  2680.     strm << setw(indent+23) << "h323GwCallsAvailable = " << setprecision(indent) << m_h323GwCallsAvailable << '\n';
  2681.   if (HasOptionalField(e_h324GwCallsAvailable))
  2682.     strm << setw(indent+23) << "h324GwCallsAvailable = " << setprecision(indent) << m_h324GwCallsAvailable << '\n';
  2683.   if (HasOptionalField(e_t120OnlyGwCallsAvailable))
  2684.     strm << setw(indent+27) << "t120OnlyGwCallsAvailable = " << setprecision(indent) << m_t120OnlyGwCallsAvailable << '\n';
  2685.   if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable))
  2686.     strm << setw(indent+35) << "t38FaxAnnexbOnlyGwCallsAvailable = " << setprecision(indent) << m_t38FaxAnnexbOnlyGwCallsAvailable << '\n';
  2687.   if (HasOptionalField(e_terminalCallsAvailable))
  2688.     strm << setw(indent+25) << "terminalCallsAvailable = " << setprecision(indent) << m_terminalCallsAvailable << '\n';
  2689.   if (HasOptionalField(e_mcuCallsAvailable))
  2690.     strm << setw(indent+20) << "mcuCallsAvailable = " << setprecision(indent) << m_mcuCallsAvailable << '\n';
  2691.   strm << setw(indent-1) << "}";
  2692. }
  2693. #endif
  2694.  
  2695.  
  2696. PObject::Comparison H225_CallCapacityInfo::Compare(const PObject & obj) const
  2697. {
  2698. #ifndef PASN_LEANANDMEAN
  2699.   PAssert(IsDescendant(H225_CallCapacityInfo::Class()), PInvalidCast);
  2700. #endif
  2701.   const H225_CallCapacityInfo & other = (const H225_CallCapacityInfo &)obj;
  2702.  
  2703.   Comparison result;
  2704.  
  2705.   if ((result = m_voiceGwCallsAvailable.Compare(other.m_voiceGwCallsAvailable)) != EqualTo)
  2706.     return result;
  2707.   if ((result = m_h310GwCallsAvailable.Compare(other.m_h310GwCallsAvailable)) != EqualTo)
  2708.     return result;
  2709.   if ((result = m_h320GwCallsAvailable.Compare(other.m_h320GwCallsAvailable)) != EqualTo)
  2710.     return result;
  2711.   if ((result = m_h321GwCallsAvailable.Compare(other.m_h321GwCallsAvailable)) != EqualTo)
  2712.     return result;
  2713.   if ((result = m_h322GwCallsAvailable.Compare(other.m_h322GwCallsAvailable)) != EqualTo)
  2714.     return result;
  2715.   if ((result = m_h323GwCallsAvailable.Compare(other.m_h323GwCallsAvailable)) != EqualTo)
  2716.     return result;
  2717.   if ((result = m_h324GwCallsAvailable.Compare(other.m_h324GwCallsAvailable)) != EqualTo)
  2718.     return result;
  2719.   if ((result = m_t120OnlyGwCallsAvailable.Compare(other.m_t120OnlyGwCallsAvailable)) != EqualTo)
  2720.     return result;
  2721.   if ((result = m_t38FaxAnnexbOnlyGwCallsAvailable.Compare(other.m_t38FaxAnnexbOnlyGwCallsAvailable)) != EqualTo)
  2722.     return result;
  2723.   if ((result = m_terminalCallsAvailable.Compare(other.m_terminalCallsAvailable)) != EqualTo)
  2724.     return result;
  2725.   if ((result = m_mcuCallsAvailable.Compare(other.m_mcuCallsAvailable)) != EqualTo)
  2726.     return result;
  2727.  
  2728.   return PASN_Sequence::Compare(other);
  2729. }
  2730.  
  2731.  
  2732. PINDEX H225_CallCapacityInfo::GetDataLength() const
  2733. {
  2734.   PINDEX length = 0;
  2735.   if (HasOptionalField(e_voiceGwCallsAvailable))
  2736.     length += m_voiceGwCallsAvailable.GetObjectLength();
  2737.   if (HasOptionalField(e_h310GwCallsAvailable))
  2738.     length += m_h310GwCallsAvailable.GetObjectLength();
  2739.   if (HasOptionalField(e_h320GwCallsAvailable))
  2740.     length += m_h320GwCallsAvailable.GetObjectLength();
  2741.   if (HasOptionalField(e_h321GwCallsAvailable))
  2742.     length += m_h321GwCallsAvailable.GetObjectLength();
  2743.   if (HasOptionalField(e_h322GwCallsAvailable))
  2744.     length += m_h322GwCallsAvailable.GetObjectLength();
  2745.   if (HasOptionalField(e_h323GwCallsAvailable))
  2746.     length += m_h323GwCallsAvailable.GetObjectLength();
  2747.   if (HasOptionalField(e_h324GwCallsAvailable))
  2748.     length += m_h324GwCallsAvailable.GetObjectLength();
  2749.   if (HasOptionalField(e_t120OnlyGwCallsAvailable))
  2750.     length += m_t120OnlyGwCallsAvailable.GetObjectLength();
  2751.   if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable))
  2752.     length += m_t38FaxAnnexbOnlyGwCallsAvailable.GetObjectLength();
  2753.   if (HasOptionalField(e_terminalCallsAvailable))
  2754.     length += m_terminalCallsAvailable.GetObjectLength();
  2755.   if (HasOptionalField(e_mcuCallsAvailable))
  2756.     length += m_mcuCallsAvailable.GetObjectLength();
  2757.   return length;
  2758. }
  2759.  
  2760.  
  2761. BOOL H225_CallCapacityInfo::Decode(PASN_Stream & strm)
  2762. {
  2763.   if (!PreambleDecode(strm))
  2764.     return FALSE;
  2765.  
  2766.   if (HasOptionalField(e_voiceGwCallsAvailable) && !m_voiceGwCallsAvailable.Decode(strm))
  2767.     return FALSE;
  2768.   if (HasOptionalField(e_h310GwCallsAvailable) && !m_h310GwCallsAvailable.Decode(strm))
  2769.     return FALSE;
  2770.   if (HasOptionalField(e_h320GwCallsAvailable) && !m_h320GwCallsAvailable.Decode(strm))
  2771.     return FALSE;
  2772.   if (HasOptionalField(e_h321GwCallsAvailable) && !m_h321GwCallsAvailable.Decode(strm))
  2773.     return FALSE;
  2774.   if (HasOptionalField(e_h322GwCallsAvailable) && !m_h322GwCallsAvailable.Decode(strm))
  2775.     return FALSE;
  2776.   if (HasOptionalField(e_h323GwCallsAvailable) && !m_h323GwCallsAvailable.Decode(strm))
  2777.     return FALSE;
  2778.   if (HasOptionalField(e_h324GwCallsAvailable) && !m_h324GwCallsAvailable.Decode(strm))
  2779.     return FALSE;
  2780.   if (HasOptionalField(e_t120OnlyGwCallsAvailable) && !m_t120OnlyGwCallsAvailable.Decode(strm))
  2781.     return FALSE;
  2782.   if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable) && !m_t38FaxAnnexbOnlyGwCallsAvailable.Decode(strm))
  2783.     return FALSE;
  2784.   if (HasOptionalField(e_terminalCallsAvailable) && !m_terminalCallsAvailable.Decode(strm))
  2785.     return FALSE;
  2786.   if (HasOptionalField(e_mcuCallsAvailable) && !m_mcuCallsAvailable.Decode(strm))
  2787.     return FALSE;
  2788.  
  2789.   return UnknownExtensionsDecode(strm);
  2790. }
  2791.  
  2792.  
  2793. void H225_CallCapacityInfo::Encode(PASN_Stream & strm) const
  2794. {
  2795.   PreambleEncode(strm);
  2796.  
  2797.   if (HasOptionalField(e_voiceGwCallsAvailable))
  2798.     m_voiceGwCallsAvailable.Encode(strm);
  2799.   if (HasOptionalField(e_h310GwCallsAvailable))
  2800.     m_h310GwCallsAvailable.Encode(strm);
  2801.   if (HasOptionalField(e_h320GwCallsAvailable))
  2802.     m_h320GwCallsAvailable.Encode(strm);
  2803.   if (HasOptionalField(e_h321GwCallsAvailable))
  2804.     m_h321GwCallsAvailable.Encode(strm);
  2805.   if (HasOptionalField(e_h322GwCallsAvailable))
  2806.     m_h322GwCallsAvailable.Encode(strm);
  2807.   if (HasOptionalField(e_h323GwCallsAvailable))
  2808.     m_h323GwCallsAvailable.Encode(strm);
  2809.   if (HasOptionalField(e_h324GwCallsAvailable))
  2810.     m_h324GwCallsAvailable.Encode(strm);
  2811.   if (HasOptionalField(e_t120OnlyGwCallsAvailable))
  2812.     m_t120OnlyGwCallsAvailable.Encode(strm);
  2813.   if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable))
  2814.     m_t38FaxAnnexbOnlyGwCallsAvailable.Encode(strm);
  2815.   if (HasOptionalField(e_terminalCallsAvailable))
  2816.     m_terminalCallsAvailable.Encode(strm);
  2817.   if (HasOptionalField(e_mcuCallsAvailable))
  2818.     m_mcuCallsAvailable.Encode(strm);
  2819.  
  2820.   UnknownExtensionsEncode(strm);
  2821. }
  2822.  
  2823.  
  2824. PObject * H225_CallCapacityInfo::Clone() const
  2825. {
  2826. #ifndef PASN_LEANANDMEAN
  2827.   PAssert(IsClass(H225_CallCapacityInfo::Class()), PInvalidCast);
  2828. #endif
  2829.   return new H225_CallCapacityInfo(*this);
  2830. }
  2831.  
  2832.  
  2833. //
  2834. // CircuitInfo
  2835. //
  2836.  
  2837. H225_CircuitInfo::H225_CircuitInfo(unsigned tag, PASN_Object::TagClass tagClass)
  2838.   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
  2839. {
  2840. }
  2841.  
  2842.  
  2843. #ifndef PASN_NOPRINTON
  2844. void H225_CircuitInfo::PrintOn(ostream & strm) const
  2845. {
  2846.   int indent = strm.precision() + 2;
  2847.   strm << "{\n";
  2848.   if (HasOptionalField(e_sourceCircuitID))
  2849.     strm << setw(indent+18) << "sourceCircuitID = " << setprecision(indent) << m_sourceCircuitID << '\n';
  2850.   if (HasOptionalField(e_destinationCircuitID))
  2851.     strm << setw(indent+23) << "destinationCircuitID = " << setprecision(indent) << m_destinationCircuitID << '\n';
  2852.   if (HasOptionalField(e_genericData))
  2853.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  2854.   strm << setw(indent-1) << "}";
  2855. }
  2856. #endif
  2857.  
  2858.  
  2859. PObject::Comparison H225_CircuitInfo::Compare(const PObject & obj) const
  2860. {
  2861. #ifndef PASN_LEANANDMEAN
  2862.   PAssert(IsDescendant(H225_CircuitInfo::Class()), PInvalidCast);
  2863. #endif
  2864.   const H225_CircuitInfo & other = (const H225_CircuitInfo &)obj;
  2865.  
  2866.   Comparison result;
  2867.  
  2868.   if ((result = m_sourceCircuitID.Compare(other.m_sourceCircuitID)) != EqualTo)
  2869.     return result;
  2870.   if ((result = m_destinationCircuitID.Compare(other.m_destinationCircuitID)) != EqualTo)
  2871.     return result;
  2872.   if ((result = m_genericData.Compare(other.m_genericData)) != EqualTo)
  2873.     return result;
  2874.  
  2875.   return PASN_Sequence::Compare(other);
  2876. }
  2877.  
  2878.  
  2879. PINDEX H225_CircuitInfo::GetDataLength() const
  2880. {
  2881.   PINDEX length = 0;
  2882.   if (HasOptionalField(e_sourceCircuitID))
  2883.     length += m_sourceCircuitID.GetObjectLength();
  2884.   if (HasOptionalField(e_destinationCircuitID))
  2885.     length += m_destinationCircuitID.GetObjectLength();
  2886.   if (HasOptionalField(e_genericData))
  2887.     length += m_genericData.GetObjectLength();
  2888.   return length;
  2889. }
  2890.  
  2891.  
  2892. BOOL H225_CircuitInfo::Decode(PASN_Stream & strm)
  2893. {
  2894.   if (!PreambleDecode(strm))
  2895.     return FALSE;
  2896.  
  2897.   if (HasOptionalField(e_sourceCircuitID) && !m_sourceCircuitID.Decode(strm))
  2898.     return FALSE;
  2899.   if (HasOptionalField(e_destinationCircuitID) && !m_destinationCircuitID.Decode(strm))
  2900.     return FALSE;
  2901.   if (HasOptionalField(e_genericData) && !m_genericData.Decode(strm))
  2902.     return FALSE;
  2903.  
  2904.   return UnknownExtensionsDecode(strm);
  2905. }
  2906.  
  2907.  
  2908. void H225_CircuitInfo::Encode(PASN_Stream & strm) const
  2909. {
  2910.   PreambleEncode(strm);
  2911.  
  2912.   if (HasOptionalField(e_sourceCircuitID))
  2913.     m_sourceCircuitID.Encode(strm);
  2914.   if (HasOptionalField(e_destinationCircuitID))
  2915.     m_destinationCircuitID.Encode(strm);
  2916.   if (HasOptionalField(e_genericData))
  2917.     m_genericData.Encode(strm);
  2918.  
  2919.   UnknownExtensionsEncode(strm);
  2920. }
  2921.  
  2922.  
  2923. PObject * H225_CircuitInfo::Clone() const
  2924. {
  2925. #ifndef PASN_LEANANDMEAN
  2926.   PAssert(IsClass(H225_CircuitInfo::Class()), PInvalidCast);
  2927. #endif
  2928.   return new H225_CircuitInfo(*this);
  2929. }
  2930.  
  2931.  
  2932. //
  2933. // CicInfo
  2934. //
  2935.  
  2936. H225_CicInfo::H225_CicInfo(unsigned tag, PASN_Object::TagClass tagClass)
  2937.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  2938. {
  2939.   m_pointCode.SetConstraints(PASN_Object::FixedConstraint, 2, 5);
  2940. }
  2941.  
  2942.  
  2943. #ifndef PASN_NOPRINTON
  2944. void H225_CicInfo::PrintOn(ostream & strm) const
  2945. {
  2946.   int indent = strm.precision() + 2;
  2947.   strm << "{\n";
  2948.   strm << setw(indent+6) << "cic = " << setprecision(indent) << m_cic << '\n';
  2949.   strm << setw(indent+12) << "pointCode = " << setprecision(indent) << m_pointCode << '\n';
  2950.   strm << setw(indent-1) << "}";
  2951. }
  2952. #endif
  2953.  
  2954.  
  2955. PObject::Comparison H225_CicInfo::Compare(const PObject & obj) const
  2956. {
  2957. #ifndef PASN_LEANANDMEAN
  2958.   PAssert(IsDescendant(H225_CicInfo::Class()), PInvalidCast);
  2959. #endif
  2960.   const H225_CicInfo & other = (const H225_CicInfo &)obj;
  2961.  
  2962.   Comparison result;
  2963.  
  2964.   if ((result = m_cic.Compare(other.m_cic)) != EqualTo)
  2965.     return result;
  2966.   if ((result = m_pointCode.Compare(other.m_pointCode)) != EqualTo)
  2967.     return result;
  2968.  
  2969.   return PASN_Sequence::Compare(other);
  2970. }
  2971.  
  2972.  
  2973. PINDEX H225_CicInfo::GetDataLength() const
  2974. {
  2975.   PINDEX length = 0;
  2976.   length += m_cic.GetObjectLength();
  2977.   length += m_pointCode.GetObjectLength();
  2978.   return length;
  2979. }
  2980.  
  2981.  
  2982. BOOL H225_CicInfo::Decode(PASN_Stream & strm)
  2983. {
  2984.   if (!PreambleDecode(strm))
  2985.     return FALSE;
  2986.  
  2987.   if (!m_cic.Decode(strm))
  2988.     return FALSE;
  2989.   if (!m_pointCode.Decode(strm))
  2990.     return FALSE;
  2991.  
  2992.   return UnknownExtensionsDecode(strm);
  2993. }
  2994.  
  2995.  
  2996. void H225_CicInfo::Encode(PASN_Stream & strm) const
  2997. {
  2998.   PreambleEncode(strm);
  2999.  
  3000.   m_cic.Encode(strm);
  3001.   m_pointCode.Encode(strm);
  3002.  
  3003.   UnknownExtensionsEncode(strm);
  3004. }
  3005.  
  3006.  
  3007. PObject * H225_CicInfo::Clone() const
  3008. {
  3009. #ifndef PASN_LEANANDMEAN
  3010.   PAssert(IsClass(H225_CicInfo::Class()), PInvalidCast);
  3011. #endif
  3012.   return new H225_CicInfo(*this);
  3013. }
  3014.  
  3015.  
  3016. //
  3017. // GroupID
  3018. //
  3019.  
  3020. H225_GroupID::H225_GroupID(unsigned tag, PASN_Object::TagClass tagClass)
  3021.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  3022. {
  3023.   m_group.SetConstraints(PASN_Object::FixedConstraint, 1, 128);
  3024. }
  3025.  
  3026.  
  3027. #ifndef PASN_NOPRINTON
  3028. void H225_GroupID::PrintOn(ostream & strm) const
  3029. {
  3030.   int indent = strm.precision() + 2;
  3031.   strm << "{\n";
  3032.   if (HasOptionalField(e_member))
  3033.     strm << setw(indent+9) << "member = " << setprecision(indent) << m_member << '\n';
  3034.   strm << setw(indent+8) << "group = " << setprecision(indent) << m_group << '\n';
  3035.   strm << setw(indent-1) << "}";
  3036. }
  3037. #endif
  3038.  
  3039.  
  3040. PObject::Comparison H225_GroupID::Compare(const PObject & obj) const
  3041. {
  3042. #ifndef PASN_LEANANDMEAN
  3043.   PAssert(IsDescendant(H225_GroupID::Class()), PInvalidCast);
  3044. #endif
  3045.   const H225_GroupID & other = (const H225_GroupID &)obj;
  3046.  
  3047.   Comparison result;
  3048.  
  3049.   if ((result = m_member.Compare(other.m_member)) != EqualTo)
  3050.     return result;
  3051.   if ((result = m_group.Compare(other.m_group)) != EqualTo)
  3052.     return result;
  3053.  
  3054.   return PASN_Sequence::Compare(other);
  3055. }
  3056.  
  3057.  
  3058. PINDEX H225_GroupID::GetDataLength() const
  3059. {
  3060.   PINDEX length = 0;
  3061.   if (HasOptionalField(e_member))
  3062.     length += m_member.GetObjectLength();
  3063.   length += m_group.GetObjectLength();
  3064.   return length;
  3065. }
  3066.  
  3067.  
  3068. BOOL H225_GroupID::Decode(PASN_Stream & strm)
  3069. {
  3070.   if (!PreambleDecode(strm))
  3071.     return FALSE;
  3072.  
  3073.   if (HasOptionalField(e_member) && !m_member.Decode(strm))
  3074.     return FALSE;
  3075.   if (!m_group.Decode(strm))
  3076.     return FALSE;
  3077.  
  3078.   return UnknownExtensionsDecode(strm);
  3079. }
  3080.  
  3081.  
  3082. void H225_GroupID::Encode(PASN_Stream & strm) const
  3083. {
  3084.   PreambleEncode(strm);
  3085.  
  3086.   if (HasOptionalField(e_member))
  3087.     m_member.Encode(strm);
  3088.   m_group.Encode(strm);
  3089.  
  3090.   UnknownExtensionsEncode(strm);
  3091. }
  3092.  
  3093.  
  3094. PObject * H225_GroupID::Clone() const
  3095. {
  3096. #ifndef PASN_LEANANDMEAN
  3097.   PAssert(IsClass(H225_GroupID::Class()), PInvalidCast);
  3098. #endif
  3099.   return new H225_GroupID(*this);
  3100. }
  3101.  
  3102.  
  3103. //
  3104. // ServiceControlSession
  3105. //
  3106.  
  3107. H225_ServiceControlSession::H225_ServiceControlSession(unsigned tag, PASN_Object::TagClass tagClass)
  3108.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  3109. {
  3110.   m_sessionId.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
  3111. }
  3112.  
  3113.  
  3114. #ifndef PASN_NOPRINTON
  3115. void H225_ServiceControlSession::PrintOn(ostream & strm) const
  3116. {
  3117.   int indent = strm.precision() + 2;
  3118.   strm << "{\n";
  3119.   strm << setw(indent+12) << "sessionId = " << setprecision(indent) << m_sessionId << '\n';
  3120.   if (HasOptionalField(e_contents))
  3121.     strm << setw(indent+11) << "contents = " << setprecision(indent) << m_contents << '\n';
  3122.   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  3123.   strm << setw(indent-1) << "}";
  3124. }
  3125. #endif
  3126.  
  3127.  
  3128. PObject::Comparison H225_ServiceControlSession::Compare(const PObject & obj) const
  3129. {
  3130. #ifndef PASN_LEANANDMEAN
  3131.   PAssert(IsDescendant(H225_ServiceControlSession::Class()), PInvalidCast);
  3132. #endif
  3133.   const H225_ServiceControlSession & other = (const H225_ServiceControlSession &)obj;
  3134.  
  3135.   Comparison result;
  3136.  
  3137.   if ((result = m_sessionId.Compare(other.m_sessionId)) != EqualTo)
  3138.     return result;
  3139.   if ((result = m_contents.Compare(other.m_contents)) != EqualTo)
  3140.     return result;
  3141.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  3142.     return result;
  3143.  
  3144.   return PASN_Sequence::Compare(other);
  3145. }
  3146.  
  3147.  
  3148. PINDEX H225_ServiceControlSession::GetDataLength() const
  3149. {
  3150.   PINDEX length = 0;
  3151.   length += m_sessionId.GetObjectLength();
  3152.   if (HasOptionalField(e_contents))
  3153.     length += m_contents.GetObjectLength();
  3154.   length += m_reason.GetObjectLength();
  3155.   return length;
  3156. }
  3157.  
  3158.  
  3159. BOOL H225_ServiceControlSession::Decode(PASN_Stream & strm)
  3160. {
  3161.   if (!PreambleDecode(strm))
  3162.     return FALSE;
  3163.  
  3164.   if (!m_sessionId.Decode(strm))
  3165.     return FALSE;
  3166.   if (HasOptionalField(e_contents) && !m_contents.Decode(strm))
  3167.     return FALSE;
  3168.   if (!m_reason.Decode(strm))
  3169.     return FALSE;
  3170.  
  3171.   return UnknownExtensionsDecode(strm);
  3172. }
  3173.  
  3174.  
  3175. void H225_ServiceControlSession::Encode(PASN_Stream & strm) const
  3176. {
  3177.   PreambleEncode(strm);
  3178.  
  3179.   m_sessionId.Encode(strm);
  3180.   if (HasOptionalField(e_contents))
  3181.     m_contents.Encode(strm);
  3182.   m_reason.Encode(strm);
  3183.  
  3184.   UnknownExtensionsEncode(strm);
  3185. }
  3186.  
  3187.  
  3188. PObject * H225_ServiceControlSession::Clone() const
  3189. {
  3190. #ifndef PASN_LEANANDMEAN
  3191.   PAssert(IsClass(H225_ServiceControlSession::Class()), PInvalidCast);
  3192. #endif
  3193.   return new H225_ServiceControlSession(*this);
  3194. }
  3195.  
  3196.  
  3197. //
  3198. // RasUsageInfoTypes
  3199. //
  3200.  
  3201. H225_RasUsageInfoTypes::H225_RasUsageInfoTypes(unsigned tag, PASN_Object::TagClass tagClass)
  3202.   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
  3203. {
  3204. }
  3205.  
  3206.  
  3207. #ifndef PASN_NOPRINTON
  3208. void H225_RasUsageInfoTypes::PrintOn(ostream & strm) const
  3209. {
  3210.   int indent = strm.precision() + 2;
  3211.   strm << "{\n";
  3212.   strm << setw(indent+24) << "nonStandardUsageTypes = " << setprecision(indent) << m_nonStandardUsageTypes << '\n';
  3213.   if (HasOptionalField(e_startTime))
  3214.     strm << setw(indent+12) << "startTime = " << setprecision(indent) << m_startTime << '\n';
  3215.   if (HasOptionalField(e_endTime))
  3216.     strm << setw(indent+10) << "endTime = " << setprecision(indent) << m_endTime << '\n';
  3217.   if (HasOptionalField(e_terminationCause))
  3218.     strm << setw(indent+19) << "terminationCause = " << setprecision(indent) << m_terminationCause << '\n';
  3219.   strm << setw(indent-1) << "}";
  3220. }
  3221. #endif
  3222.  
  3223.  
  3224. PObject::Comparison H225_RasUsageInfoTypes::Compare(const PObject & obj) const
  3225. {
  3226. #ifndef PASN_LEANANDMEAN
  3227.   PAssert(IsDescendant(H225_RasUsageInfoTypes::Class()), PInvalidCast);
  3228. #endif
  3229.   const H225_RasUsageInfoTypes & other = (const H225_RasUsageInfoTypes &)obj;
  3230.  
  3231.   Comparison result;
  3232.  
  3233.   if ((result = m_nonStandardUsageTypes.Compare(other.m_nonStandardUsageTypes)) != EqualTo)
  3234.     return result;
  3235.   if ((result = m_startTime.Compare(other.m_startTime)) != EqualTo)
  3236.     return result;
  3237.   if ((result = m_endTime.Compare(other.m_endTime)) != EqualTo)
  3238.     return result;
  3239.   if ((result = m_terminationCause.Compare(other.m_terminationCause)) != EqualTo)
  3240.     return result;
  3241.  
  3242.   return PASN_Sequence::Compare(other);
  3243. }
  3244.  
  3245.  
  3246. PINDEX H225_RasUsageInfoTypes::GetDataLength() const
  3247. {
  3248.   PINDEX length = 0;
  3249.   length += m_nonStandardUsageTypes.GetObjectLength();
  3250.   if (HasOptionalField(e_startTime))
  3251.     length += m_startTime.GetObjectLength();
  3252.   if (HasOptionalField(e_endTime))
  3253.     length += m_endTime.GetObjectLength();
  3254.   if (HasOptionalField(e_terminationCause))
  3255.     length += m_terminationCause.GetObjectLength();
  3256.   return length;
  3257. }
  3258.  
  3259.  
  3260. BOOL H225_RasUsageInfoTypes::Decode(PASN_Stream & strm)
  3261. {
  3262.   if (!PreambleDecode(strm))
  3263.     return FALSE;
  3264.  
  3265.   if (!m_nonStandardUsageTypes.Decode(strm))
  3266.     return FALSE;
  3267.   if (HasOptionalField(e_startTime) && !m_startTime.Decode(strm))
  3268.     return FALSE;
  3269.   if (HasOptionalField(e_endTime) && !m_endTime.Decode(strm))
  3270.     return FALSE;
  3271.   if (HasOptionalField(e_terminationCause) && !m_terminationCause.Decode(strm))
  3272.     return FALSE;
  3273.  
  3274.   return UnknownExtensionsDecode(strm);
  3275. }
  3276.  
  3277.  
  3278. void H225_RasUsageInfoTypes::Encode(PASN_Stream & strm) const
  3279. {
  3280.   PreambleEncode(strm);
  3281.  
  3282.   m_nonStandardUsageTypes.Encode(strm);
  3283.   if (HasOptionalField(e_startTime))
  3284.     m_startTime.Encode(strm);
  3285.   if (HasOptionalField(e_endTime))
  3286.     m_endTime.Encode(strm);
  3287.   if (HasOptionalField(e_terminationCause))
  3288.     m_terminationCause.Encode(strm);
  3289.  
  3290.   UnknownExtensionsEncode(strm);
  3291. }
  3292.  
  3293.  
  3294. PObject * H225_RasUsageInfoTypes::Clone() const
  3295. {
  3296. #ifndef PASN_LEANANDMEAN
  3297.   PAssert(IsClass(H225_RasUsageInfoTypes::Class()), PInvalidCast);
  3298. #endif
  3299.   return new H225_RasUsageInfoTypes(*this);
  3300. }
  3301.  
  3302.  
  3303. //
  3304. // RasUsageSpecification
  3305. //
  3306.  
  3307. H225_RasUsageSpecification::H225_RasUsageSpecification(unsigned tag, PASN_Object::TagClass tagClass)
  3308.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  3309. {
  3310. }
  3311.  
  3312.  
  3313. #ifndef PASN_NOPRINTON
  3314. void H225_RasUsageSpecification::PrintOn(ostream & strm) const
  3315. {
  3316.   int indent = strm.precision() + 2;
  3317.   strm << "{\n";
  3318.   strm << setw(indent+7) << "when = " << setprecision(indent) << m_when << '\n';
  3319.   if (HasOptionalField(e_callStartingPoint))
  3320.     strm << setw(indent+20) << "callStartingPoint = " << setprecision(indent) << m_callStartingPoint << '\n';
  3321.   strm << setw(indent+11) << "required = " << setprecision(indent) << m_required << '\n';
  3322.   strm << setw(indent-1) << "}";
  3323. }
  3324. #endif
  3325.  
  3326.  
  3327. PObject::Comparison H225_RasUsageSpecification::Compare(const PObject & obj) const
  3328. {
  3329. #ifndef PASN_LEANANDMEAN
  3330.   PAssert(IsDescendant(H225_RasUsageSpecification::Class()), PInvalidCast);
  3331. #endif
  3332.   const H225_RasUsageSpecification & other = (const H225_RasUsageSpecification &)obj;
  3333.  
  3334.   Comparison result;
  3335.  
  3336.   if ((result = m_when.Compare(other.m_when)) != EqualTo)
  3337.     return result;
  3338.   if ((result = m_callStartingPoint.Compare(other.m_callStartingPoint)) != EqualTo)
  3339.     return result;
  3340.   if ((result = m_required.Compare(other.m_required)) != EqualTo)
  3341.     return result;
  3342.  
  3343.   return PASN_Sequence::Compare(other);
  3344. }
  3345.  
  3346.  
  3347. PINDEX H225_RasUsageSpecification::GetDataLength() const
  3348. {
  3349.   PINDEX length = 0;
  3350.   length += m_when.GetObjectLength();
  3351.   if (HasOptionalField(e_callStartingPoint))
  3352.     length += m_callStartingPoint.GetObjectLength();
  3353.   length += m_required.GetObjectLength();
  3354.   return length;
  3355. }
  3356.  
  3357.  
  3358. BOOL H225_RasUsageSpecification::Decode(PASN_Stream & strm)
  3359. {
  3360.   if (!PreambleDecode(strm))
  3361.     return FALSE;
  3362.  
  3363.   if (!m_when.Decode(strm))
  3364.     return FALSE;
  3365.   if (HasOptionalField(e_callStartingPoint) && !m_callStartingPoint.Decode(strm))
  3366.     return FALSE;
  3367.   if (!m_required.Decode(strm))
  3368.     return FALSE;
  3369.  
  3370.   return UnknownExtensionsDecode(strm);
  3371. }
  3372.  
  3373.  
  3374. void H225_RasUsageSpecification::Encode(PASN_Stream & strm) const
  3375. {
  3376.   PreambleEncode(strm);
  3377.  
  3378.   m_when.Encode(strm);
  3379.   if (HasOptionalField(e_callStartingPoint))
  3380.     m_callStartingPoint.Encode(strm);
  3381.   m_required.Encode(strm);
  3382.  
  3383.   UnknownExtensionsEncode(strm);
  3384. }
  3385.  
  3386.  
  3387. PObject * H225_RasUsageSpecification::Clone() const
  3388. {
  3389. #ifndef PASN_LEANANDMEAN
  3390.   PAssert(IsClass(H225_RasUsageSpecification::Class()), PInvalidCast);
  3391. #endif
  3392.   return new H225_RasUsageSpecification(*this);
  3393. }
  3394.  
  3395.  
  3396. //
  3397. // RasUsageInformation
  3398. //
  3399.  
  3400. H225_RasUsageInformation::H225_RasUsageInformation(unsigned tag, PASN_Object::TagClass tagClass)
  3401.   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
  3402. {
  3403. }
  3404.  
  3405.  
  3406. #ifndef PASN_NOPRINTON
  3407. void H225_RasUsageInformation::PrintOn(ostream & strm) const
  3408. {
  3409.   int indent = strm.precision() + 2;
  3410.   strm << "{\n";
  3411.   strm << setw(indent+25) << "nonStandardUsageFields = " << setprecision(indent) << m_nonStandardUsageFields << '\n';
  3412.   if (HasOptionalField(e_alertingTime))
  3413.     strm << setw(indent+15) << "alertingTime = " << setprecision(indent) << m_alertingTime << '\n';
  3414.   if (HasOptionalField(e_connectTime))
  3415.     strm << setw(indent+14) << "connectTime = " << setprecision(indent) << m_connectTime << '\n';
  3416.   if (HasOptionalField(e_endTime))
  3417.     strm << setw(indent+10) << "endTime = " << setprecision(indent) << m_endTime << '\n';
  3418.   strm << setw(indent-1) << "}";
  3419. }
  3420. #endif
  3421.  
  3422.  
  3423. PObject::Comparison H225_RasUsageInformation::Compare(const PObject & obj) const
  3424. {
  3425. #ifndef PASN_LEANANDMEAN
  3426.   PAssert(IsDescendant(H225_RasUsageInformation::Class()), PInvalidCast);
  3427. #endif
  3428.   const H225_RasUsageInformation & other = (const H225_RasUsageInformation &)obj;
  3429.  
  3430.   Comparison result;
  3431.  
  3432.   if ((result = m_nonStandardUsageFields.Compare(other.m_nonStandardUsageFields)) != EqualTo)
  3433.     return result;
  3434.   if ((result = m_alertingTime.Compare(other.m_alertingTime)) != EqualTo)
  3435.     return result;
  3436.   if ((result = m_connectTime.Compare(other.m_connectTime)) != EqualTo)
  3437.     return result;
  3438.   if ((result = m_endTime.Compare(other.m_endTime)) != EqualTo)
  3439.     return result;
  3440.  
  3441.   return PASN_Sequence::Compare(other);
  3442. }
  3443.  
  3444.  
  3445. PINDEX H225_RasUsageInformation::GetDataLength() const
  3446. {
  3447.   PINDEX length = 0;
  3448.   length += m_nonStandardUsageFields.GetObjectLength();
  3449.   if (HasOptionalField(e_alertingTime))
  3450.     length += m_alertingTime.GetObjectLength();
  3451.   if (HasOptionalField(e_connectTime))
  3452.     length += m_connectTime.GetObjectLength();
  3453.   if (HasOptionalField(e_endTime))
  3454.     length += m_endTime.GetObjectLength();
  3455.   return length;
  3456. }
  3457.  
  3458.  
  3459. BOOL H225_RasUsageInformation::Decode(PASN_Stream & strm)
  3460. {
  3461.   if (!PreambleDecode(strm))
  3462.     return FALSE;
  3463.  
  3464.   if (!m_nonStandardUsageFields.Decode(strm))
  3465.     return FALSE;
  3466.   if (HasOptionalField(e_alertingTime) && !m_alertingTime.Decode(strm))
  3467.     return FALSE;
  3468.   if (HasOptionalField(e_connectTime) && !m_connectTime.Decode(strm))
  3469.     return FALSE;
  3470.   if (HasOptionalField(e_endTime) && !m_endTime.Decode(strm))
  3471.     return FALSE;
  3472.  
  3473.   return UnknownExtensionsDecode(strm);
  3474. }
  3475.  
  3476.  
  3477. void H225_RasUsageInformation::Encode(PASN_Stream & strm) const
  3478. {
  3479.   PreambleEncode(strm);
  3480.  
  3481.   m_nonStandardUsageFields.Encode(strm);
  3482.   if (HasOptionalField(e_alertingTime))
  3483.     m_alertingTime.Encode(strm);
  3484.   if (HasOptionalField(e_connectTime))
  3485.     m_connectTime.Encode(strm);
  3486.   if (HasOptionalField(e_endTime))
  3487.     m_endTime.Encode(strm);
  3488.  
  3489.   UnknownExtensionsEncode(strm);
  3490. }
  3491.  
  3492.  
  3493. PObject * H225_RasUsageInformation::Clone() const
  3494. {
  3495. #ifndef PASN_LEANANDMEAN
  3496.   PAssert(IsClass(H225_RasUsageInformation::Class()), PInvalidCast);
  3497. #endif
  3498.   return new H225_RasUsageInformation(*this);
  3499. }
  3500.  
  3501.  
  3502. //
  3503. // BandwidthDetails
  3504. //
  3505.  
  3506. H225_BandwidthDetails::H225_BandwidthDetails(unsigned tag, PASN_Object::TagClass tagClass)
  3507.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3508. {
  3509. }
  3510.  
  3511.  
  3512. #ifndef PASN_NOPRINTON
  3513. void H225_BandwidthDetails::PrintOn(ostream & strm) const
  3514. {
  3515.   int indent = strm.precision() + 2;
  3516.   strm << "{\n";
  3517.   strm << setw(indent+9) << "sender = " << setprecision(indent) << m_sender << '\n';
  3518.   strm << setw(indent+12) << "multicast = " << setprecision(indent) << m_multicast << '\n';
  3519.   strm << setw(indent+12) << "bandwidth = " << setprecision(indent) << m_bandwidth << '\n';
  3520.   strm << setw(indent+16) << "rtcpAddresses = " << setprecision(indent) << m_rtcpAddresses << '\n';
  3521.   strm << setw(indent-1) << "}";
  3522. }
  3523. #endif
  3524.  
  3525.  
  3526. PObject::Comparison H225_BandwidthDetails::Compare(const PObject & obj) const
  3527. {
  3528. #ifndef PASN_LEANANDMEAN
  3529.   PAssert(IsDescendant(H225_BandwidthDetails::Class()), PInvalidCast);
  3530. #endif
  3531.   const H225_BandwidthDetails & other = (const H225_BandwidthDetails &)obj;
  3532.  
  3533.   Comparison result;
  3534.  
  3535.   if ((result = m_sender.Compare(other.m_sender)) != EqualTo)
  3536.     return result;
  3537.   if ((result = m_multicast.Compare(other.m_multicast)) != EqualTo)
  3538.     return result;
  3539.   if ((result = m_bandwidth.Compare(other.m_bandwidth)) != EqualTo)
  3540.     return result;
  3541.   if ((result = m_rtcpAddresses.Compare(other.m_rtcpAddresses)) != EqualTo)
  3542.     return result;
  3543.  
  3544.   return PASN_Sequence::Compare(other);
  3545. }
  3546.  
  3547.  
  3548. PINDEX H225_BandwidthDetails::GetDataLength() const
  3549. {
  3550.   PINDEX length = 0;
  3551.   length += m_sender.GetObjectLength();
  3552.   length += m_multicast.GetObjectLength();
  3553.   length += m_bandwidth.GetObjectLength();
  3554.   length += m_rtcpAddresses.GetObjectLength();
  3555.   return length;
  3556. }
  3557.  
  3558.  
  3559. BOOL H225_BandwidthDetails::Decode(PASN_Stream & strm)
  3560. {
  3561.   if (!PreambleDecode(strm))
  3562.     return FALSE;
  3563.  
  3564.   if (!m_sender.Decode(strm))
  3565.     return FALSE;
  3566.   if (!m_multicast.Decode(strm))
  3567.     return FALSE;
  3568.   if (!m_bandwidth.Decode(strm))
  3569.     return FALSE;
  3570.   if (!m_rtcpAddresses.Decode(strm))
  3571.     return FALSE;
  3572.  
  3573.   return UnknownExtensionsDecode(strm);
  3574. }
  3575.  
  3576.  
  3577. void H225_BandwidthDetails::Encode(PASN_Stream & strm) const
  3578. {
  3579.   PreambleEncode(strm);
  3580.  
  3581.   m_sender.Encode(strm);
  3582.   m_multicast.Encode(strm);
  3583.   m_bandwidth.Encode(strm);
  3584.   m_rtcpAddresses.Encode(strm);
  3585.  
  3586.   UnknownExtensionsEncode(strm);
  3587. }
  3588.  
  3589.  
  3590. PObject * H225_BandwidthDetails::Clone() const
  3591. {
  3592. #ifndef PASN_LEANANDMEAN
  3593.   PAssert(IsClass(H225_BandwidthDetails::Class()), PInvalidCast);
  3594. #endif
  3595.   return new H225_BandwidthDetails(*this);
  3596. }
  3597.  
  3598.  
  3599. //
  3600. // CallCreditServiceControl
  3601. //
  3602.  
  3603. H225_CallCreditServiceControl::H225_CallCreditServiceControl(unsigned tag, PASN_Object::TagClass tagClass)
  3604.   : PASN_Sequence(tag, tagClass, 5, TRUE, 0)
  3605. {
  3606.   m_amountString.SetConstraints(PASN_Object::FixedConstraint, 1, 512);
  3607.   m_callDurationLimit.SetConstraints(PASN_Object::FixedConstraint, 1, 4294967295U);
  3608. }
  3609.  
  3610.  
  3611. #ifndef PASN_NOPRINTON
  3612. void H225_CallCreditServiceControl::PrintOn(ostream & strm) const
  3613. {
  3614.   int indent = strm.precision() + 2;
  3615.   strm << "{\n";
  3616.   if (HasOptionalField(e_amountString))
  3617.     strm << setw(indent+15) << "amountString = " << setprecision(indent) << m_amountString << '\n';
  3618.   if (HasOptionalField(e_billingMode))
  3619.     strm << setw(indent+14) << "billingMode = " << setprecision(indent) << m_billingMode << '\n';
  3620.   if (HasOptionalField(e_callDurationLimit))
  3621.     strm << setw(indent+20) << "callDurationLimit = " << setprecision(indent) << m_callDurationLimit << '\n';
  3622.   if (HasOptionalField(e_enforceCallDurationLimit))
  3623.     strm << setw(indent+27) << "enforceCallDurationLimit = " << setprecision(indent) << m_enforceCallDurationLimit << '\n';
  3624.   if (HasOptionalField(e_callStartingPoint))
  3625.     strm << setw(indent+20) << "callStartingPoint = " << setprecision(indent) << m_callStartingPoint << '\n';
  3626.   strm << setw(indent-1) << "}";
  3627. }
  3628. #endif
  3629.  
  3630.  
  3631. PObject::Comparison H225_CallCreditServiceControl::Compare(const PObject & obj) const
  3632. {
  3633. #ifndef PASN_LEANANDMEAN
  3634.   PAssert(IsDescendant(H225_CallCreditServiceControl::Class()), PInvalidCast);
  3635. #endif
  3636.   const H225_CallCreditServiceControl & other = (const H225_CallCreditServiceControl &)obj;
  3637.  
  3638.   Comparison result;
  3639.  
  3640.   if ((result = m_amountString.Compare(other.m_amountString)) != EqualTo)
  3641.     return result;
  3642.   if ((result = m_billingMode.Compare(other.m_billingMode)) != EqualTo)
  3643.     return result;
  3644.   if ((result = m_callDurationLimit.Compare(other.m_callDurationLimit)) != EqualTo)
  3645.     return result;
  3646.   if ((result = m_enforceCallDurationLimit.Compare(other.m_enforceCallDurationLimit)) != EqualTo)
  3647.     return result;
  3648.   if ((result = m_callStartingPoint.Compare(other.m_callStartingPoint)) != EqualTo)
  3649.     return result;
  3650.  
  3651.   return PASN_Sequence::Compare(other);
  3652. }
  3653.  
  3654.  
  3655. PINDEX H225_CallCreditServiceControl::GetDataLength() const
  3656. {
  3657.   PINDEX length = 0;
  3658.   if (HasOptionalField(e_amountString))
  3659.     length += m_amountString.GetObjectLength();
  3660.   if (HasOptionalField(e_billingMode))
  3661.     length += m_billingMode.GetObjectLength();
  3662.   if (HasOptionalField(e_callDurationLimit))
  3663.     length += m_callDurationLimit.GetObjectLength();
  3664.   if (HasOptionalField(e_enforceCallDurationLimit))
  3665.     length += m_enforceCallDurationLimit.GetObjectLength();
  3666.   if (HasOptionalField(e_callStartingPoint))
  3667.     length += m_callStartingPoint.GetObjectLength();
  3668.   return length;
  3669. }
  3670.  
  3671.  
  3672. BOOL H225_CallCreditServiceControl::Decode(PASN_Stream & strm)
  3673. {
  3674.   if (!PreambleDecode(strm))
  3675.     return FALSE;
  3676.  
  3677.   if (HasOptionalField(e_amountString) && !m_amountString.Decode(strm))
  3678.     return FALSE;
  3679.   if (HasOptionalField(e_billingMode) && !m_billingMode.Decode(strm))
  3680.     return FALSE;
  3681.   if (HasOptionalField(e_callDurationLimit) && !m_callDurationLimit.Decode(strm))
  3682.     return FALSE;
  3683.   if (HasOptionalField(e_enforceCallDurationLimit) && !m_enforceCallDurationLimit.Decode(strm))
  3684.     return FALSE;
  3685.   if (HasOptionalField(e_callStartingPoint) && !m_callStartingPoint.Decode(strm))
  3686.     return FALSE;
  3687.  
  3688.   return UnknownExtensionsDecode(strm);
  3689. }
  3690.  
  3691.  
  3692. void H225_CallCreditServiceControl::Encode(PASN_Stream & strm) const
  3693. {
  3694.   PreambleEncode(strm);
  3695.  
  3696.   if (HasOptionalField(e_amountString))
  3697.     m_amountString.Encode(strm);
  3698.   if (HasOptionalField(e_billingMode))
  3699.     m_billingMode.Encode(strm);
  3700.   if (HasOptionalField(e_callDurationLimit))
  3701.     m_callDurationLimit.Encode(strm);
  3702.   if (HasOptionalField(e_enforceCallDurationLimit))
  3703.     m_enforceCallDurationLimit.Encode(strm);
  3704.   if (HasOptionalField(e_callStartingPoint))
  3705.     m_callStartingPoint.Encode(strm);
  3706.  
  3707.   UnknownExtensionsEncode(strm);
  3708. }
  3709.  
  3710.  
  3711. PObject * H225_CallCreditServiceControl::Clone() const
  3712. {
  3713. #ifndef PASN_LEANANDMEAN
  3714.   PAssert(IsClass(H225_CallCreditServiceControl::Class()), PInvalidCast);
  3715. #endif
  3716.   return new H225_CallCreditServiceControl(*this);
  3717. }
  3718.  
  3719.  
  3720. //
  3721. // GenericData
  3722. //
  3723.  
  3724. H225_GenericData::H225_GenericData(unsigned tag, PASN_Object::TagClass tagClass)
  3725.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  3726. {
  3727.   m_parameters.SetConstraints(PASN_Object::FixedConstraint, 1, 512);
  3728. }
  3729.  
  3730.  
  3731. #ifndef PASN_NOPRINTON
  3732. void H225_GenericData::PrintOn(ostream & strm) const
  3733. {
  3734.   int indent = strm.precision() + 2;
  3735.   strm << "{\n";
  3736.   strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
  3737.   if (HasOptionalField(e_parameters))
  3738.     strm << setw(indent+13) << "parameters = " << setprecision(indent) << m_parameters << '\n';
  3739.   strm << setw(indent-1) << "}";
  3740. }
  3741. #endif
  3742.  
  3743.  
  3744. PObject::Comparison H225_GenericData::Compare(const PObject & obj) const
  3745. {
  3746. #ifndef PASN_LEANANDMEAN
  3747.   PAssert(IsDescendant(H225_GenericData::Class()), PInvalidCast);
  3748. #endif
  3749.   const H225_GenericData & other = (const H225_GenericData &)obj;
  3750.  
  3751.   Comparison result;
  3752.  
  3753.   if ((result = m_id.Compare(other.m_id)) != EqualTo)
  3754.     return result;
  3755.   if ((result = m_parameters.Compare(other.m_parameters)) != EqualTo)
  3756.     return result;
  3757.  
  3758.   return PASN_Sequence::Compare(other);
  3759. }
  3760.  
  3761.  
  3762. PINDEX H225_GenericData::GetDataLength() const
  3763. {
  3764.   PINDEX length = 0;
  3765.   length += m_id.GetObjectLength();
  3766.   if (HasOptionalField(e_parameters))
  3767.     length += m_parameters.GetObjectLength();
  3768.   return length;
  3769. }
  3770.  
  3771.  
  3772. BOOL H225_GenericData::Decode(PASN_Stream & strm)
  3773. {
  3774.   if (!PreambleDecode(strm))
  3775.     return FALSE;
  3776.  
  3777.   if (!m_id.Decode(strm))
  3778.     return FALSE;
  3779.   if (HasOptionalField(e_parameters) && !m_parameters.Decode(strm))
  3780.     return FALSE;
  3781.  
  3782.   return UnknownExtensionsDecode(strm);
  3783. }
  3784.  
  3785.  
  3786. void H225_GenericData::Encode(PASN_Stream & strm) const
  3787. {
  3788.   PreambleEncode(strm);
  3789.  
  3790.   m_id.Encode(strm);
  3791.   if (HasOptionalField(e_parameters))
  3792.     m_parameters.Encode(strm);
  3793.  
  3794.   UnknownExtensionsEncode(strm);
  3795. }
  3796.  
  3797.  
  3798. PObject * H225_GenericData::Clone() const
  3799. {
  3800. #ifndef PASN_LEANANDMEAN
  3801.   PAssert(IsClass(H225_GenericData::Class()), PInvalidCast);
  3802. #endif
  3803.   return new H225_GenericData(*this);
  3804. }
  3805.  
  3806.  
  3807. //
  3808. // EnumeratedParameter
  3809. //
  3810.  
  3811. H225_EnumeratedParameter::H225_EnumeratedParameter(unsigned tag, PASN_Object::TagClass tagClass)
  3812.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  3813. {
  3814. }
  3815.  
  3816.  
  3817. #ifndef PASN_NOPRINTON
  3818. void H225_EnumeratedParameter::PrintOn(ostream & strm) const
  3819. {
  3820.   int indent = strm.precision() + 2;
  3821.   strm << "{\n";
  3822.   strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
  3823.   if (HasOptionalField(e_content))
  3824.     strm << setw(indent+10) << "content = " << setprecision(indent) << m_content << '\n';
  3825.   strm << setw(indent-1) << "}";
  3826. }
  3827. #endif
  3828.  
  3829.  
  3830. PObject::Comparison H225_EnumeratedParameter::Compare(const PObject & obj) const
  3831. {
  3832. #ifndef PASN_LEANANDMEAN
  3833.   PAssert(IsDescendant(H225_EnumeratedParameter::Class()), PInvalidCast);
  3834. #endif
  3835.   const H225_EnumeratedParameter & other = (const H225_EnumeratedParameter &)obj;
  3836.  
  3837.   Comparison result;
  3838.  
  3839.   if ((result = m_id.Compare(other.m_id)) != EqualTo)
  3840.     return result;
  3841.   if ((result = m_content.Compare(other.m_content)) != EqualTo)
  3842.     return result;
  3843.  
  3844.   return PASN_Sequence::Compare(other);
  3845. }
  3846.  
  3847.  
  3848. PINDEX H225_EnumeratedParameter::GetDataLength() const
  3849. {
  3850.   PINDEX length = 0;
  3851.   length += m_id.GetObjectLength();
  3852.   if (HasOptionalField(e_content))
  3853.     length += m_content.GetObjectLength();
  3854.   return length;
  3855. }
  3856.  
  3857.  
  3858. BOOL H225_EnumeratedParameter::Decode(PASN_Stream & strm)
  3859. {
  3860.   if (!PreambleDecode(strm))
  3861.     return FALSE;
  3862.  
  3863.   if (!m_id.Decode(strm))
  3864.     return FALSE;
  3865.   if (HasOptionalField(e_content) && !m_content.Decode(strm))
  3866.     return FALSE;
  3867.  
  3868.   return UnknownExtensionsDecode(strm);
  3869. }
  3870.  
  3871.  
  3872. void H225_EnumeratedParameter::Encode(PASN_Stream & strm) const
  3873. {
  3874.   PreambleEncode(strm);
  3875.  
  3876.   m_id.Encode(strm);
  3877.   if (HasOptionalField(e_content))
  3878.     m_content.Encode(strm);
  3879.  
  3880.   UnknownExtensionsEncode(strm);
  3881. }
  3882.  
  3883.  
  3884. PObject * H225_EnumeratedParameter::Clone() const
  3885. {
  3886. #ifndef PASN_LEANANDMEAN
  3887.   PAssert(IsClass(H225_EnumeratedParameter::Class()), PInvalidCast);
  3888. #endif
  3889.   return new H225_EnumeratedParameter(*this);
  3890. }
  3891.  
  3892.  
  3893. //
  3894. // FeatureSet
  3895. //
  3896.  
  3897. H225_FeatureSet::H225_FeatureSet(unsigned tag, PASN_Object::TagClass tagClass)
  3898.   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
  3899. {
  3900. }
  3901.  
  3902.  
  3903. #ifndef PASN_NOPRINTON
  3904. void H225_FeatureSet::PrintOn(ostream & strm) const
  3905. {
  3906.   int indent = strm.precision() + 2;
  3907.   strm << "{\n";
  3908.   strm << setw(indent+24) << "replacementFeatureSet = " << setprecision(indent) << m_replacementFeatureSet << '\n';
  3909.   if (HasOptionalField(e_neededFeatures))
  3910.     strm << setw(indent+17) << "neededFeatures = " << setprecision(indent) << m_neededFeatures << '\n';
  3911.   if (HasOptionalField(e_desiredFeatures))
  3912.     strm << setw(indent+18) << "desiredFeatures = " << setprecision(indent) << m_desiredFeatures << '\n';
  3913.   if (HasOptionalField(e_supportedFeatures))
  3914.     strm << setw(indent+20) << "supportedFeatures = " << setprecision(indent) << m_supportedFeatures << '\n';
  3915.   strm << setw(indent-1) << "}";
  3916. }
  3917. #endif
  3918.  
  3919.  
  3920. PObject::Comparison H225_FeatureSet::Compare(const PObject & obj) const
  3921. {
  3922. #ifndef PASN_LEANANDMEAN
  3923.   PAssert(IsDescendant(H225_FeatureSet::Class()), PInvalidCast);
  3924. #endif
  3925.   const H225_FeatureSet & other = (const H225_FeatureSet &)obj;
  3926.  
  3927.   Comparison result;
  3928.  
  3929.   if ((result = m_replacementFeatureSet.Compare(other.m_replacementFeatureSet)) != EqualTo)
  3930.     return result;
  3931.   if ((result = m_neededFeatures.Compare(other.m_neededFeatures)) != EqualTo)
  3932.     return result;
  3933.   if ((result = m_desiredFeatures.Compare(other.m_desiredFeatures)) != EqualTo)
  3934.     return result;
  3935.   if ((result = m_supportedFeatures.Compare(other.m_supportedFeatures)) != EqualTo)
  3936.     return result;
  3937.  
  3938.   return PASN_Sequence::Compare(other);
  3939. }
  3940.  
  3941.  
  3942. PINDEX H225_FeatureSet::GetDataLength() const
  3943. {
  3944.   PINDEX length = 0;
  3945.   length += m_replacementFeatureSet.GetObjectLength();
  3946.   if (HasOptionalField(e_neededFeatures))
  3947.     length += m_neededFeatures.GetObjectLength();
  3948.   if (HasOptionalField(e_desiredFeatures))
  3949.     length += m_desiredFeatures.GetObjectLength();
  3950.   if (HasOptionalField(e_supportedFeatures))
  3951.     length += m_supportedFeatures.GetObjectLength();
  3952.   return length;
  3953. }
  3954.  
  3955.  
  3956. BOOL H225_FeatureSet::Decode(PASN_Stream & strm)
  3957. {
  3958.   if (!PreambleDecode(strm))
  3959.     return FALSE;
  3960.  
  3961.   if (!m_replacementFeatureSet.Decode(strm))
  3962.     return FALSE;
  3963.   if (HasOptionalField(e_neededFeatures) && !m_neededFeatures.Decode(strm))
  3964.     return FALSE;
  3965.   if (HasOptionalField(e_desiredFeatures) && !m_desiredFeatures.Decode(strm))
  3966.     return FALSE;
  3967.   if (HasOptionalField(e_supportedFeatures) && !m_supportedFeatures.Decode(strm))
  3968.     return FALSE;
  3969.  
  3970.   return UnknownExtensionsDecode(strm);
  3971. }
  3972.  
  3973.  
  3974. void H225_FeatureSet::Encode(PASN_Stream & strm) const
  3975. {
  3976.   PreambleEncode(strm);
  3977.  
  3978.   m_replacementFeatureSet.Encode(strm);
  3979.   if (HasOptionalField(e_neededFeatures))
  3980.     m_neededFeatures.Encode(strm);
  3981.   if (HasOptionalField(e_desiredFeatures))
  3982.     m_desiredFeatures.Encode(strm);
  3983.   if (HasOptionalField(e_supportedFeatures))
  3984.     m_supportedFeatures.Encode(strm);
  3985.  
  3986.   UnknownExtensionsEncode(strm);
  3987. }
  3988.  
  3989.  
  3990. PObject * H225_FeatureSet::Clone() const
  3991. {
  3992. #ifndef PASN_LEANANDMEAN
  3993.   PAssert(IsClass(H225_FeatureSet::Class()), PInvalidCast);
  3994. #endif
  3995.   return new H225_FeatureSet(*this);
  3996. }
  3997.  
  3998.  
  3999. //
  4000. // RTPSession
  4001. //
  4002.  
  4003. H225_RTPSession::H225_RTPSession(unsigned tag, PASN_Object::TagClass tagClass)
  4004.   : PASN_Sequence(tag, tagClass, 0, TRUE, 2)
  4005. {
  4006.   m_ssrc.SetConstraints(PASN_Object::FixedConstraint, 1, 4294967295U);
  4007.   m_sessionId.SetConstraints(PASN_Object::FixedConstraint, 1, 255);
  4008. }
  4009.  
  4010.  
  4011. #ifndef PASN_NOPRINTON
  4012. void H225_RTPSession::PrintOn(ostream & strm) const
  4013. {
  4014.   int indent = strm.precision() + 2;
  4015.   strm << "{\n";
  4016.   strm << setw(indent+13) << "rtpAddress = " << setprecision(indent) << m_rtpAddress << '\n';
  4017.   strm << setw(indent+14) << "rtcpAddress = " << setprecision(indent) << m_rtcpAddress << '\n';
  4018.   strm << setw(indent+8) << "cname = " << setprecision(indent) << m_cname << '\n';
  4019.   strm << setw(indent+7) << "ssrc = " << setprecision(indent) << m_ssrc << '\n';
  4020.   strm << setw(indent+12) << "sessionId = " << setprecision(indent) << m_sessionId << '\n';
  4021.   strm << setw(indent+23) << "associatedSessionIds = " << setprecision(indent) << m_associatedSessionIds << '\n';
  4022.   if (HasOptionalField(e_multicast))
  4023.     strm << setw(indent+12) << "multicast = " << setprecision(indent) << m_multicast << '\n';
  4024.   if (HasOptionalField(e_bandwidth))
  4025.     strm << setw(indent+12) << "bandwidth = " << setprecision(indent) << m_bandwidth << '\n';
  4026.   strm << setw(indent-1) << "}";
  4027. }
  4028. #endif
  4029.  
  4030.  
  4031. PObject::Comparison H225_RTPSession::Compare(const PObject & obj) const
  4032. {
  4033. #ifndef PASN_LEANANDMEAN
  4034.   PAssert(IsDescendant(H225_RTPSession::Class()), PInvalidCast);
  4035. #endif
  4036.   const H225_RTPSession & other = (const H225_RTPSession &)obj;
  4037.  
  4038.   Comparison result;
  4039.  
  4040.   if ((result = m_rtpAddress.Compare(other.m_rtpAddress)) != EqualTo)
  4041.     return result;
  4042.   if ((result = m_rtcpAddress.Compare(other.m_rtcpAddress)) != EqualTo)
  4043.     return result;
  4044.   if ((result = m_cname.Compare(other.m_cname)) != EqualTo)
  4045.     return result;
  4046.   if ((result = m_ssrc.Compare(other.m_ssrc)) != EqualTo)
  4047.     return result;
  4048.   if ((result = m_sessionId.Compare(other.m_sessionId)) != EqualTo)
  4049.     return result;
  4050.   if ((result = m_associatedSessionIds.Compare(other.m_associatedSessionIds)) != EqualTo)
  4051.     return result;
  4052.  
  4053.   return PASN_Sequence::Compare(other);
  4054. }
  4055.  
  4056.  
  4057. PINDEX H225_RTPSession::GetDataLength() const
  4058. {
  4059.   PINDEX length = 0;
  4060.   length += m_rtpAddress.GetObjectLength();
  4061.   length += m_rtcpAddress.GetObjectLength();
  4062.   length += m_cname.GetObjectLength();
  4063.   length += m_ssrc.GetObjectLength();
  4064.   length += m_sessionId.GetObjectLength();
  4065.   length += m_associatedSessionIds.GetObjectLength();
  4066.   return length;
  4067. }
  4068.  
  4069.  
  4070. BOOL H225_RTPSession::Decode(PASN_Stream & strm)
  4071. {
  4072.   if (!PreambleDecode(strm))
  4073.     return FALSE;
  4074.  
  4075.   if (!m_rtpAddress.Decode(strm))
  4076.     return FALSE;
  4077.   if (!m_rtcpAddress.Decode(strm))
  4078.     return FALSE;
  4079.   if (!m_cname.Decode(strm))
  4080.     return FALSE;
  4081.   if (!m_ssrc.Decode(strm))
  4082.     return FALSE;
  4083.   if (!m_sessionId.Decode(strm))
  4084.     return FALSE;
  4085.   if (!m_associatedSessionIds.Decode(strm))
  4086.     return FALSE;
  4087.   if (!KnownExtensionDecode(strm, e_multicast, m_multicast))
  4088.     return FALSE;
  4089.   if (!KnownExtensionDecode(strm, e_bandwidth, m_bandwidth))
  4090.     return FALSE;
  4091.  
  4092.   return UnknownExtensionsDecode(strm);
  4093. }
  4094.  
  4095.  
  4096. void H225_RTPSession::Encode(PASN_Stream & strm) const
  4097. {
  4098.   PreambleEncode(strm);
  4099.  
  4100.   m_rtpAddress.Encode(strm);
  4101.   m_rtcpAddress.Encode(strm);
  4102.   m_cname.Encode(strm);
  4103.   m_ssrc.Encode(strm);
  4104.   m_sessionId.Encode(strm);
  4105.   m_associatedSessionIds.Encode(strm);
  4106.   KnownExtensionEncode(strm, e_multicast, m_multicast);
  4107.   KnownExtensionEncode(strm, e_bandwidth, m_bandwidth);
  4108.  
  4109.   UnknownExtensionsEncode(strm);
  4110. }
  4111.  
  4112.  
  4113. PObject * H225_RTPSession::Clone() const
  4114. {
  4115. #ifndef PASN_LEANANDMEAN
  4116.   PAssert(IsClass(H225_RTPSession::Class()), PInvalidCast);
  4117. #endif
  4118.   return new H225_RTPSession(*this);
  4119. }
  4120.  
  4121.  
  4122. //
  4123. // GatekeeperConfirm
  4124. //
  4125.  
  4126. H225_GatekeeperConfirm::H225_GatekeeperConfirm(unsigned tag, PASN_Object::TagClass tagClass)
  4127.   : PASN_Sequence(tag, tagClass, 2, TRUE, 9)
  4128. {
  4129. }
  4130.  
  4131.  
  4132. #ifndef PASN_NOPRINTON
  4133. void H225_GatekeeperConfirm::PrintOn(ostream & strm) const
  4134. {
  4135.   int indent = strm.precision() + 2;
  4136.   strm << "{\n";
  4137.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  4138.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  4139.   if (HasOptionalField(e_nonStandardData))
  4140.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  4141.   if (HasOptionalField(e_gatekeeperIdentifier))
  4142.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  4143.   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
  4144.   if (HasOptionalField(e_alternateGatekeeper))
  4145.     strm << setw(indent+22) << "alternateGatekeeper = " << setprecision(indent) << m_alternateGatekeeper << '\n';
  4146.   if (HasOptionalField(e_authenticationMode))
  4147.     strm << setw(indent+21) << "authenticationMode = " << setprecision(indent) << m_authenticationMode << '\n';
  4148.   if (HasOptionalField(e_tokens))
  4149.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  4150.   if (HasOptionalField(e_cryptoTokens))
  4151.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  4152.   if (HasOptionalField(e_algorithmOID))
  4153.     strm << setw(indent+15) << "algorithmOID = " << setprecision(indent) << m_algorithmOID << '\n';
  4154.   if (HasOptionalField(e_integrity))
  4155.     strm << setw(indent+12) << "integrity = " << setprecision(indent) << m_integrity << '\n';
  4156.   if (HasOptionalField(e_integrityCheckValue))
  4157.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  4158.   if (HasOptionalField(e_featureSet))
  4159.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  4160.   if (HasOptionalField(e_genericData))
  4161.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  4162.   strm << setw(indent-1) << "}";
  4163. }
  4164. #endif
  4165.  
  4166.  
  4167. PObject::Comparison H225_GatekeeperConfirm::Compare(const PObject & obj) const
  4168. {
  4169. #ifndef PASN_LEANANDMEAN
  4170.   PAssert(IsDescendant(H225_GatekeeperConfirm::Class()), PInvalidCast);
  4171. #endif
  4172.   const H225_GatekeeperConfirm & other = (const H225_GatekeeperConfirm &)obj;
  4173.  
  4174.   Comparison result;
  4175.  
  4176.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  4177.     return result;
  4178.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  4179.     return result;
  4180.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  4181.     return result;
  4182.   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
  4183.     return result;
  4184.   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
  4185.     return result;
  4186.  
  4187.   return PASN_Sequence::Compare(other);
  4188. }
  4189.  
  4190.  
  4191. PINDEX H225_GatekeeperConfirm::GetDataLength() const
  4192. {
  4193.   PINDEX length = 0;
  4194.   length += m_requestSeqNum.GetObjectLength();
  4195.   length += m_protocolIdentifier.GetObjectLength();
  4196.   if (HasOptionalField(e_nonStandardData))
  4197.     length += m_nonStandardData.GetObjectLength();
  4198.   if (HasOptionalField(e_gatekeeperIdentifier))
  4199.     length += m_gatekeeperIdentifier.GetObjectLength();
  4200.   length += m_rasAddress.GetObjectLength();
  4201.   return length;
  4202. }
  4203.  
  4204.  
  4205. BOOL H225_GatekeeperConfirm::Decode(PASN_Stream & strm)
  4206. {
  4207.   if (!PreambleDecode(strm))
  4208.     return FALSE;
  4209.  
  4210.   if (!m_requestSeqNum.Decode(strm))
  4211.     return FALSE;
  4212.   if (!m_protocolIdentifier.Decode(strm))
  4213.     return FALSE;
  4214.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  4215.     return FALSE;
  4216.   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
  4217.     return FALSE;
  4218.   if (!m_rasAddress.Decode(strm))
  4219.     return FALSE;
  4220.   if (!KnownExtensionDecode(strm, e_alternateGatekeeper, m_alternateGatekeeper))
  4221.     return FALSE;
  4222.   if (!KnownExtensionDecode(strm, e_authenticationMode, m_authenticationMode))
  4223.     return FALSE;
  4224.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  4225.     return FALSE;
  4226.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  4227.     return FALSE;
  4228.   if (!KnownExtensionDecode(strm, e_algorithmOID, m_algorithmOID))
  4229.     return FALSE;
  4230.   if (!KnownExtensionDecode(strm, e_integrity, m_integrity))
  4231.     return FALSE;
  4232.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  4233.     return FALSE;
  4234.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  4235.     return FALSE;
  4236.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  4237.     return FALSE;
  4238.  
  4239.   return UnknownExtensionsDecode(strm);
  4240. }
  4241.  
  4242.  
  4243. void H225_GatekeeperConfirm::Encode(PASN_Stream & strm) const
  4244. {
  4245.   PreambleEncode(strm);
  4246.  
  4247.   m_requestSeqNum.Encode(strm);
  4248.   m_protocolIdentifier.Encode(strm);
  4249.   if (HasOptionalField(e_nonStandardData))
  4250.     m_nonStandardData.Encode(strm);
  4251.   if (HasOptionalField(e_gatekeeperIdentifier))
  4252.     m_gatekeeperIdentifier.Encode(strm);
  4253.   m_rasAddress.Encode(strm);
  4254.   KnownExtensionEncode(strm, e_alternateGatekeeper, m_alternateGatekeeper);
  4255.   KnownExtensionEncode(strm, e_authenticationMode, m_authenticationMode);
  4256.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  4257.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  4258.   KnownExtensionEncode(strm, e_algorithmOID, m_algorithmOID);
  4259.   KnownExtensionEncode(strm, e_integrity, m_integrity);
  4260.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  4261.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  4262.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  4263.  
  4264.   UnknownExtensionsEncode(strm);
  4265. }
  4266.  
  4267.  
  4268. PObject * H225_GatekeeperConfirm::Clone() const
  4269. {
  4270. #ifndef PASN_LEANANDMEAN
  4271.   PAssert(IsClass(H225_GatekeeperConfirm::Class()), PInvalidCast);
  4272. #endif
  4273.   return new H225_GatekeeperConfirm(*this);
  4274. }
  4275.  
  4276.  
  4277. //
  4278. // GatekeeperReject
  4279. //
  4280.  
  4281. H225_GatekeeperReject::H225_GatekeeperReject(unsigned tag, PASN_Object::TagClass tagClass)
  4282.   : PASN_Sequence(tag, tagClass, 2, TRUE, 6)
  4283. {
  4284. }
  4285.  
  4286.  
  4287. #ifndef PASN_NOPRINTON
  4288. void H225_GatekeeperReject::PrintOn(ostream & strm) const
  4289. {
  4290.   int indent = strm.precision() + 2;
  4291.   strm << "{\n";
  4292.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  4293.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  4294.   if (HasOptionalField(e_nonStandardData))
  4295.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  4296.   if (HasOptionalField(e_gatekeeperIdentifier))
  4297.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  4298.   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
  4299.   if (HasOptionalField(e_altGKInfo))
  4300.     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
  4301.   if (HasOptionalField(e_tokens))
  4302.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  4303.   if (HasOptionalField(e_cryptoTokens))
  4304.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  4305.   if (HasOptionalField(e_integrityCheckValue))
  4306.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  4307.   if (HasOptionalField(e_featureSet))
  4308.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  4309.   if (HasOptionalField(e_genericData))
  4310.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  4311.   strm << setw(indent-1) << "}";
  4312. }
  4313. #endif
  4314.  
  4315.  
  4316. PObject::Comparison H225_GatekeeperReject::Compare(const PObject & obj) const
  4317. {
  4318. #ifndef PASN_LEANANDMEAN
  4319.   PAssert(IsDescendant(H225_GatekeeperReject::Class()), PInvalidCast);
  4320. #endif
  4321.   const H225_GatekeeperReject & other = (const H225_GatekeeperReject &)obj;
  4322.  
  4323.   Comparison result;
  4324.  
  4325.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  4326.     return result;
  4327.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  4328.     return result;
  4329.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  4330.     return result;
  4331.   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
  4332.     return result;
  4333.   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
  4334.     return result;
  4335.  
  4336.   return PASN_Sequence::Compare(other);
  4337. }
  4338.  
  4339.  
  4340. PINDEX H225_GatekeeperReject::GetDataLength() const
  4341. {
  4342.   PINDEX length = 0;
  4343.   length += m_requestSeqNum.GetObjectLength();
  4344.   length += m_protocolIdentifier.GetObjectLength();
  4345.   if (HasOptionalField(e_nonStandardData))
  4346.     length += m_nonStandardData.GetObjectLength();
  4347.   if (HasOptionalField(e_gatekeeperIdentifier))
  4348.     length += m_gatekeeperIdentifier.GetObjectLength();
  4349.   length += m_rejectReason.GetObjectLength();
  4350.   return length;
  4351. }
  4352.  
  4353.  
  4354. BOOL H225_GatekeeperReject::Decode(PASN_Stream & strm)
  4355. {
  4356.   if (!PreambleDecode(strm))
  4357.     return FALSE;
  4358.  
  4359.   if (!m_requestSeqNum.Decode(strm))
  4360.     return FALSE;
  4361.   if (!m_protocolIdentifier.Decode(strm))
  4362.     return FALSE;
  4363.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  4364.     return FALSE;
  4365.   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
  4366.     return FALSE;
  4367.   if (!m_rejectReason.Decode(strm))
  4368.     return FALSE;
  4369.   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
  4370.     return FALSE;
  4371.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  4372.     return FALSE;
  4373.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  4374.     return FALSE;
  4375.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  4376.     return FALSE;
  4377.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  4378.     return FALSE;
  4379.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  4380.     return FALSE;
  4381.  
  4382.   return UnknownExtensionsDecode(strm);
  4383. }
  4384.  
  4385.  
  4386. void H225_GatekeeperReject::Encode(PASN_Stream & strm) const
  4387. {
  4388.   PreambleEncode(strm);
  4389.  
  4390.   m_requestSeqNum.Encode(strm);
  4391.   m_protocolIdentifier.Encode(strm);
  4392.   if (HasOptionalField(e_nonStandardData))
  4393.     m_nonStandardData.Encode(strm);
  4394.   if (HasOptionalField(e_gatekeeperIdentifier))
  4395.     m_gatekeeperIdentifier.Encode(strm);
  4396.   m_rejectReason.Encode(strm);
  4397.   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
  4398.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  4399.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  4400.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  4401.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  4402.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  4403.  
  4404.   UnknownExtensionsEncode(strm);
  4405. }
  4406.  
  4407.  
  4408. PObject * H225_GatekeeperReject::Clone() const
  4409. {
  4410. #ifndef PASN_LEANANDMEAN
  4411.   PAssert(IsClass(H225_GatekeeperReject::Class()), PInvalidCast);
  4412. #endif
  4413.   return new H225_GatekeeperReject(*this);
  4414. }
  4415.  
  4416.  
  4417. //
  4418. // RegistrationReject
  4419. //
  4420.  
  4421. H225_RegistrationReject::H225_RegistrationReject(unsigned tag, PASN_Object::TagClass tagClass)
  4422.   : PASN_Sequence(tag, tagClass, 2, TRUE, 6)
  4423. {
  4424. }
  4425.  
  4426.  
  4427. #ifndef PASN_NOPRINTON
  4428. void H225_RegistrationReject::PrintOn(ostream & strm) const
  4429. {
  4430.   int indent = strm.precision() + 2;
  4431.   strm << "{\n";
  4432.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  4433.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  4434.   if (HasOptionalField(e_nonStandardData))
  4435.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  4436.   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
  4437.   if (HasOptionalField(e_gatekeeperIdentifier))
  4438.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  4439.   if (HasOptionalField(e_altGKInfo))
  4440.     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
  4441.   if (HasOptionalField(e_tokens))
  4442.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  4443.   if (HasOptionalField(e_cryptoTokens))
  4444.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  4445.   if (HasOptionalField(e_integrityCheckValue))
  4446.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  4447.   if (HasOptionalField(e_featureSet))
  4448.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  4449.   if (HasOptionalField(e_genericData))
  4450.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  4451.   strm << setw(indent-1) << "}";
  4452. }
  4453. #endif
  4454.  
  4455.  
  4456. PObject::Comparison H225_RegistrationReject::Compare(const PObject & obj) const
  4457. {
  4458. #ifndef PASN_LEANANDMEAN
  4459.   PAssert(IsDescendant(H225_RegistrationReject::Class()), PInvalidCast);
  4460. #endif
  4461.   const H225_RegistrationReject & other = (const H225_RegistrationReject &)obj;
  4462.  
  4463.   Comparison result;
  4464.  
  4465.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  4466.     return result;
  4467.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  4468.     return result;
  4469.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  4470.     return result;
  4471.   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
  4472.     return result;
  4473.   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
  4474.     return result;
  4475.  
  4476.   return PASN_Sequence::Compare(other);
  4477. }
  4478.  
  4479.  
  4480. PINDEX H225_RegistrationReject::GetDataLength() const
  4481. {
  4482.   PINDEX length = 0;
  4483.   length += m_requestSeqNum.GetObjectLength();
  4484.   length += m_protocolIdentifier.GetObjectLength();
  4485.   if (HasOptionalField(e_nonStandardData))
  4486.     length += m_nonStandardData.GetObjectLength();
  4487.   length += m_rejectReason.GetObjectLength();
  4488.   if (HasOptionalField(e_gatekeeperIdentifier))
  4489.     length += m_gatekeeperIdentifier.GetObjectLength();
  4490.   return length;
  4491. }
  4492.  
  4493.  
  4494. BOOL H225_RegistrationReject::Decode(PASN_Stream & strm)
  4495. {
  4496.   if (!PreambleDecode(strm))
  4497.     return FALSE;
  4498.  
  4499.   if (!m_requestSeqNum.Decode(strm))
  4500.     return FALSE;
  4501.   if (!m_protocolIdentifier.Decode(strm))
  4502.     return FALSE;
  4503.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  4504.     return FALSE;
  4505.   if (!m_rejectReason.Decode(strm))
  4506.     return FALSE;
  4507.   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
  4508.     return FALSE;
  4509.   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
  4510.     return FALSE;
  4511.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  4512.     return FALSE;
  4513.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  4514.     return FALSE;
  4515.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  4516.     return FALSE;
  4517.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  4518.     return FALSE;
  4519.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  4520.     return FALSE;
  4521.  
  4522.   return UnknownExtensionsDecode(strm);
  4523. }
  4524.  
  4525.  
  4526. void H225_RegistrationReject::Encode(PASN_Stream & strm) const
  4527. {
  4528.   PreambleEncode(strm);
  4529.  
  4530.   m_requestSeqNum.Encode(strm);
  4531.   m_protocolIdentifier.Encode(strm);
  4532.   if (HasOptionalField(e_nonStandardData))
  4533.     m_nonStandardData.Encode(strm);
  4534.   m_rejectReason.Encode(strm);
  4535.   if (HasOptionalField(e_gatekeeperIdentifier))
  4536.     m_gatekeeperIdentifier.Encode(strm);
  4537.   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
  4538.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  4539.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  4540.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  4541.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  4542.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  4543.  
  4544.   UnknownExtensionsEncode(strm);
  4545. }
  4546.  
  4547.  
  4548. PObject * H225_RegistrationReject::Clone() const
  4549. {
  4550. #ifndef PASN_LEANANDMEAN
  4551.   PAssert(IsClass(H225_RegistrationReject::Class()), PInvalidCast);
  4552. #endif
  4553.   return new H225_RegistrationReject(*this);
  4554. }
  4555.  
  4556.  
  4557. //
  4558. // UnregistrationRequest
  4559. //
  4560.  
  4561. H225_UnregistrationRequest::H225_UnregistrationRequest(unsigned tag, PASN_Object::TagClass tagClass)
  4562.   : PASN_Sequence(tag, tagClass, 3, TRUE, 10)
  4563. {
  4564. }
  4565.  
  4566.  
  4567. #ifndef PASN_NOPRINTON
  4568. void H225_UnregistrationRequest::PrintOn(ostream & strm) const
  4569. {
  4570.   int indent = strm.precision() + 2;
  4571.   strm << "{\n";
  4572.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  4573.   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
  4574.   if (HasOptionalField(e_endpointAlias))
  4575.     strm << setw(indent+16) << "endpointAlias = " << setprecision(indent) << m_endpointAlias << '\n';
  4576.   if (HasOptionalField(e_nonStandardData))
  4577.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  4578.   if (HasOptionalField(e_endpointIdentifier))
  4579.     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  4580.   if (HasOptionalField(e_alternateEndpoints))
  4581.     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
  4582.   if (HasOptionalField(e_gatekeeperIdentifier))
  4583.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  4584.   if (HasOptionalField(e_tokens))
  4585.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  4586.   if (HasOptionalField(e_cryptoTokens))
  4587.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  4588.   if (HasOptionalField(e_integrityCheckValue))
  4589.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  4590.   if (HasOptionalField(e_reason))
  4591.     strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  4592.   if (HasOptionalField(e_endpointAliasPattern))
  4593.     strm << setw(indent+23) << "endpointAliasPattern = " << setprecision(indent) << m_endpointAliasPattern << '\n';
  4594.   if (HasOptionalField(e_supportedPrefixes))
  4595.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  4596.   if (HasOptionalField(e_alternateGatekeeper))
  4597.     strm << setw(indent+22) << "alternateGatekeeper = " << setprecision(indent) << m_alternateGatekeeper << '\n';
  4598.   if (HasOptionalField(e_genericData))
  4599.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  4600.   strm << setw(indent-1) << "}";
  4601. }
  4602. #endif
  4603.  
  4604.  
  4605. PObject::Comparison H225_UnregistrationRequest::Compare(const PObject & obj) const
  4606. {
  4607. #ifndef PASN_LEANANDMEAN
  4608.   PAssert(IsDescendant(H225_UnregistrationRequest::Class()), PInvalidCast);
  4609. #endif
  4610.   const H225_UnregistrationRequest & other = (const H225_UnregistrationRequest &)obj;
  4611.  
  4612.   Comparison result;
  4613.  
  4614.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  4615.     return result;
  4616.   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
  4617.     return result;
  4618.   if ((result = m_endpointAlias.Compare(other.m_endpointAlias)) != EqualTo)
  4619.     return result;
  4620.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  4621.     return result;
  4622.   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
  4623.     return result;
  4624.  
  4625.   return PASN_Sequence::Compare(other);
  4626. }
  4627.  
  4628.  
  4629. PINDEX H225_UnregistrationRequest::GetDataLength() const
  4630. {
  4631.   PINDEX length = 0;
  4632.   length += m_requestSeqNum.GetObjectLength();
  4633.   length += m_callSignalAddress.GetObjectLength();
  4634.   if (HasOptionalField(e_endpointAlias))
  4635.     length += m_endpointAlias.GetObjectLength();
  4636.   if (HasOptionalField(e_nonStandardData))
  4637.     length += m_nonStandardData.GetObjectLength();
  4638.   if (HasOptionalField(e_endpointIdentifier))
  4639.     length += m_endpointIdentifier.GetObjectLength();
  4640.   return length;
  4641. }
  4642.  
  4643.  
  4644. BOOL H225_UnregistrationRequest::Decode(PASN_Stream & strm)
  4645. {
  4646.   if (!PreambleDecode(strm))
  4647.     return FALSE;
  4648.  
  4649.   if (!m_requestSeqNum.Decode(strm))
  4650.     return FALSE;
  4651.   if (!m_callSignalAddress.Decode(strm))
  4652.     return FALSE;
  4653.   if (HasOptionalField(e_endpointAlias) && !m_endpointAlias.Decode(strm))
  4654.     return FALSE;
  4655.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  4656.     return FALSE;
  4657.   if (HasOptionalField(e_endpointIdentifier) && !m_endpointIdentifier.Decode(strm))
  4658.     return FALSE;
  4659.   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
  4660.     return FALSE;
  4661.   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
  4662.     return FALSE;
  4663.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  4664.     return FALSE;
  4665.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  4666.     return FALSE;
  4667.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  4668.     return FALSE;
  4669.   if (!KnownExtensionDecode(strm, e_reason, m_reason))
  4670.     return FALSE;
  4671.   if (!KnownExtensionDecode(strm, e_endpointAliasPattern, m_endpointAliasPattern))
  4672.     return FALSE;
  4673.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  4674.     return FALSE;
  4675.   if (!KnownExtensionDecode(strm, e_alternateGatekeeper, m_alternateGatekeeper))
  4676.     return FALSE;
  4677.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  4678.     return FALSE;
  4679.  
  4680.   return UnknownExtensionsDecode(strm);
  4681. }
  4682.  
  4683.  
  4684. void H225_UnregistrationRequest::Encode(PASN_Stream & strm) const
  4685. {
  4686.   PreambleEncode(strm);
  4687.  
  4688.   m_requestSeqNum.Encode(strm);
  4689.   m_callSignalAddress.Encode(strm);
  4690.   if (HasOptionalField(e_endpointAlias))
  4691.     m_endpointAlias.Encode(strm);
  4692.   if (HasOptionalField(e_nonStandardData))
  4693.     m_nonStandardData.Encode(strm);
  4694.   if (HasOptionalField(e_endpointIdentifier))
  4695.     m_endpointIdentifier.Encode(strm);
  4696.   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
  4697.   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
  4698.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  4699.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  4700.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  4701.   KnownExtensionEncode(strm, e_reason, m_reason);
  4702.   KnownExtensionEncode(strm, e_endpointAliasPattern, m_endpointAliasPattern);
  4703.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  4704.   KnownExtensionEncode(strm, e_alternateGatekeeper, m_alternateGatekeeper);
  4705.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  4706.  
  4707.   UnknownExtensionsEncode(strm);
  4708. }
  4709.  
  4710.  
  4711. PObject * H225_UnregistrationRequest::Clone() const
  4712. {
  4713. #ifndef PASN_LEANANDMEAN
  4714.   PAssert(IsClass(H225_UnregistrationRequest::Class()), PInvalidCast);
  4715. #endif
  4716.   return new H225_UnregistrationRequest(*this);
  4717. }
  4718.  
  4719.  
  4720. //
  4721. // UnregistrationConfirm
  4722. //
  4723.  
  4724. H225_UnregistrationConfirm::H225_UnregistrationConfirm(unsigned tag, PASN_Object::TagClass tagClass)
  4725.   : PASN_Sequence(tag, tagClass, 1, TRUE, 4)
  4726. {
  4727. }
  4728.  
  4729.  
  4730. #ifndef PASN_NOPRINTON
  4731. void H225_UnregistrationConfirm::PrintOn(ostream & strm) const
  4732. {
  4733.   int indent = strm.precision() + 2;
  4734.   strm << "{\n";
  4735.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  4736.   if (HasOptionalField(e_nonStandardData))
  4737.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  4738.   if (HasOptionalField(e_tokens))
  4739.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  4740.   if (HasOptionalField(e_cryptoTokens))
  4741.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  4742.   if (HasOptionalField(e_integrityCheckValue))
  4743.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  4744.   if (HasOptionalField(e_genericData))
  4745.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  4746.   strm << setw(indent-1) << "}";
  4747. }
  4748. #endif
  4749.  
  4750.  
  4751. PObject::Comparison H225_UnregistrationConfirm::Compare(const PObject & obj) const
  4752. {
  4753. #ifndef PASN_LEANANDMEAN
  4754.   PAssert(IsDescendant(H225_UnregistrationConfirm::Class()), PInvalidCast);
  4755. #endif
  4756.   const H225_UnregistrationConfirm & other = (const H225_UnregistrationConfirm &)obj;
  4757.  
  4758.   Comparison result;
  4759.  
  4760.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  4761.     return result;
  4762.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  4763.     return result;
  4764.  
  4765.   return PASN_Sequence::Compare(other);
  4766. }
  4767.  
  4768.  
  4769. PINDEX H225_UnregistrationConfirm::GetDataLength() const
  4770. {
  4771.   PINDEX length = 0;
  4772.   length += m_requestSeqNum.GetObjectLength();
  4773.   if (HasOptionalField(e_nonStandardData))
  4774.     length += m_nonStandardData.GetObjectLength();
  4775.   return length;
  4776. }
  4777.  
  4778.  
  4779. BOOL H225_UnregistrationConfirm::Decode(PASN_Stream & strm)
  4780. {
  4781.   if (!PreambleDecode(strm))
  4782.     return FALSE;
  4783.  
  4784.   if (!m_requestSeqNum.Decode(strm))
  4785.     return FALSE;
  4786.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  4787.     return FALSE;
  4788.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  4789.     return FALSE;
  4790.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  4791.     return FALSE;
  4792.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  4793.     return FALSE;
  4794.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  4795.     return FALSE;
  4796.  
  4797.   return UnknownExtensionsDecode(strm);
  4798. }
  4799.  
  4800.  
  4801. void H225_UnregistrationConfirm::Encode(PASN_Stream & strm) const
  4802. {
  4803.   PreambleEncode(strm);
  4804.  
  4805.   m_requestSeqNum.Encode(strm);
  4806.   if (HasOptionalField(e_nonStandardData))
  4807.     m_nonStandardData.Encode(strm);
  4808.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  4809.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  4810.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  4811.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  4812.  
  4813.   UnknownExtensionsEncode(strm);
  4814. }
  4815.  
  4816.  
  4817. PObject * H225_UnregistrationConfirm::Clone() const
  4818. {
  4819. #ifndef PASN_LEANANDMEAN
  4820.   PAssert(IsClass(H225_UnregistrationConfirm::Class()), PInvalidCast);
  4821. #endif
  4822.   return new H225_UnregistrationConfirm(*this);
  4823. }
  4824.  
  4825.  
  4826. //
  4827. // UnregistrationReject
  4828. //
  4829.  
  4830. H225_UnregistrationReject::H225_UnregistrationReject(unsigned tag, PASN_Object::TagClass tagClass)
  4831.   : PASN_Sequence(tag, tagClass, 1, TRUE, 5)
  4832. {
  4833. }
  4834.  
  4835.  
  4836. #ifndef PASN_NOPRINTON
  4837. void H225_UnregistrationReject::PrintOn(ostream & strm) const
  4838. {
  4839.   int indent = strm.precision() + 2;
  4840.   strm << "{\n";
  4841.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  4842.   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
  4843.   if (HasOptionalField(e_nonStandardData))
  4844.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  4845.   if (HasOptionalField(e_altGKInfo))
  4846.     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
  4847.   if (HasOptionalField(e_tokens))
  4848.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  4849.   if (HasOptionalField(e_cryptoTokens))
  4850.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  4851.   if (HasOptionalField(e_integrityCheckValue))
  4852.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  4853.   if (HasOptionalField(e_genericData))
  4854.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  4855.   strm << setw(indent-1) << "}";
  4856. }
  4857. #endif
  4858.  
  4859.  
  4860. PObject::Comparison H225_UnregistrationReject::Compare(const PObject & obj) const
  4861. {
  4862. #ifndef PASN_LEANANDMEAN
  4863.   PAssert(IsDescendant(H225_UnregistrationReject::Class()), PInvalidCast);
  4864. #endif
  4865.   const H225_UnregistrationReject & other = (const H225_UnregistrationReject &)obj;
  4866.  
  4867.   Comparison result;
  4868.  
  4869.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  4870.     return result;
  4871.   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
  4872.     return result;
  4873.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  4874.     return result;
  4875.  
  4876.   return PASN_Sequence::Compare(other);
  4877. }
  4878.  
  4879.  
  4880. PINDEX H225_UnregistrationReject::GetDataLength() const
  4881. {
  4882.   PINDEX length = 0;
  4883.   length += m_requestSeqNum.GetObjectLength();
  4884.   length += m_rejectReason.GetObjectLength();
  4885.   if (HasOptionalField(e_nonStandardData))
  4886.     length += m_nonStandardData.GetObjectLength();
  4887.   return length;
  4888. }
  4889.  
  4890.  
  4891. BOOL H225_UnregistrationReject::Decode(PASN_Stream & strm)
  4892. {
  4893.   if (!PreambleDecode(strm))
  4894.     return FALSE;
  4895.  
  4896.   if (!m_requestSeqNum.Decode(strm))
  4897.     return FALSE;
  4898.   if (!m_rejectReason.Decode(strm))
  4899.     return FALSE;
  4900.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  4901.     return FALSE;
  4902.   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
  4903.     return FALSE;
  4904.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  4905.     return FALSE;
  4906.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  4907.     return FALSE;
  4908.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  4909.     return FALSE;
  4910.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  4911.     return FALSE;
  4912.  
  4913.   return UnknownExtensionsDecode(strm);
  4914. }
  4915.  
  4916.  
  4917. void H225_UnregistrationReject::Encode(PASN_Stream & strm) const
  4918. {
  4919.   PreambleEncode(strm);
  4920.  
  4921.   m_requestSeqNum.Encode(strm);
  4922.   m_rejectReason.Encode(strm);
  4923.   if (HasOptionalField(e_nonStandardData))
  4924.     m_nonStandardData.Encode(strm);
  4925.   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
  4926.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  4927.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  4928.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  4929.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  4930.  
  4931.   UnknownExtensionsEncode(strm);
  4932. }
  4933.  
  4934.  
  4935. PObject * H225_UnregistrationReject::Clone() const
  4936. {
  4937. #ifndef PASN_LEANANDMEAN
  4938.   PAssert(IsClass(H225_UnregistrationReject::Class()), PInvalidCast);
  4939. #endif
  4940.   return new H225_UnregistrationReject(*this);
  4941. }
  4942.  
  4943.  
  4944. //
  4945. // AdmissionReject
  4946. //
  4947.  
  4948. H225_AdmissionReject::H225_AdmissionReject(unsigned tag, PASN_Object::TagClass tagClass)
  4949.   : PASN_Sequence(tag, tagClass, 1, TRUE, 8)
  4950. {
  4951. }
  4952.  
  4953.  
  4954. #ifndef PASN_NOPRINTON
  4955. void H225_AdmissionReject::PrintOn(ostream & strm) const
  4956. {
  4957.   int indent = strm.precision() + 2;
  4958.   strm << "{\n";
  4959.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  4960.   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
  4961.   if (HasOptionalField(e_nonStandardData))
  4962.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  4963.   if (HasOptionalField(e_altGKInfo))
  4964.     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
  4965.   if (HasOptionalField(e_tokens))
  4966.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  4967.   if (HasOptionalField(e_cryptoTokens))
  4968.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  4969.   if (HasOptionalField(e_callSignalAddress))
  4970.     strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
  4971.   if (HasOptionalField(e_integrityCheckValue))
  4972.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  4973.   if (HasOptionalField(e_serviceControl))
  4974.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  4975.   if (HasOptionalField(e_featureSet))
  4976.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  4977.   if (HasOptionalField(e_genericData))
  4978.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  4979.   strm << setw(indent-1) << "}";
  4980. }
  4981. #endif
  4982.  
  4983.  
  4984. PObject::Comparison H225_AdmissionReject::Compare(const PObject & obj) const
  4985. {
  4986. #ifndef PASN_LEANANDMEAN
  4987.   PAssert(IsDescendant(H225_AdmissionReject::Class()), PInvalidCast);
  4988. #endif
  4989.   const H225_AdmissionReject & other = (const H225_AdmissionReject &)obj;
  4990.  
  4991.   Comparison result;
  4992.  
  4993.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  4994.     return result;
  4995.   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
  4996.     return result;
  4997.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  4998.     return result;
  4999.  
  5000.   return PASN_Sequence::Compare(other);
  5001. }
  5002.  
  5003.  
  5004. PINDEX H225_AdmissionReject::GetDataLength() const
  5005. {
  5006.   PINDEX length = 0;
  5007.   length += m_requestSeqNum.GetObjectLength();
  5008.   length += m_rejectReason.GetObjectLength();
  5009.   if (HasOptionalField(e_nonStandardData))
  5010.     length += m_nonStandardData.GetObjectLength();
  5011.   return length;
  5012. }
  5013.  
  5014.  
  5015. BOOL H225_AdmissionReject::Decode(PASN_Stream & strm)
  5016. {
  5017.   if (!PreambleDecode(strm))
  5018.     return FALSE;
  5019.  
  5020.   if (!m_requestSeqNum.Decode(strm))
  5021.     return FALSE;
  5022.   if (!m_rejectReason.Decode(strm))
  5023.     return FALSE;
  5024.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  5025.     return FALSE;
  5026.   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
  5027.     return FALSE;
  5028.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  5029.     return FALSE;
  5030.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  5031.     return FALSE;
  5032.   if (!KnownExtensionDecode(strm, e_callSignalAddress, m_callSignalAddress))
  5033.     return FALSE;
  5034.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  5035.     return FALSE;
  5036.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  5037.     return FALSE;
  5038.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  5039.     return FALSE;
  5040.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  5041.     return FALSE;
  5042.  
  5043.   return UnknownExtensionsDecode(strm);
  5044. }
  5045.  
  5046.  
  5047. void H225_AdmissionReject::Encode(PASN_Stream & strm) const
  5048. {
  5049.   PreambleEncode(strm);
  5050.  
  5051.   m_requestSeqNum.Encode(strm);
  5052.   m_rejectReason.Encode(strm);
  5053.   if (HasOptionalField(e_nonStandardData))
  5054.     m_nonStandardData.Encode(strm);
  5055.   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
  5056.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  5057.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  5058.   KnownExtensionEncode(strm, e_callSignalAddress, m_callSignalAddress);
  5059.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  5060.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  5061.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  5062.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  5063.  
  5064.   UnknownExtensionsEncode(strm);
  5065. }
  5066.  
  5067.  
  5068. PObject * H225_AdmissionReject::Clone() const
  5069. {
  5070. #ifndef PASN_LEANANDMEAN
  5071.   PAssert(IsClass(H225_AdmissionReject::Class()), PInvalidCast);
  5072. #endif
  5073.   return new H225_AdmissionReject(*this);
  5074. }
  5075.  
  5076.  
  5077. //
  5078. // BandwidthReject
  5079. //
  5080.  
  5081. H225_BandwidthReject::H225_BandwidthReject(unsigned tag, PASN_Object::TagClass tagClass)
  5082.   : PASN_Sequence(tag, tagClass, 1, TRUE, 5)
  5083. {
  5084. }
  5085.  
  5086.  
  5087. #ifndef PASN_NOPRINTON
  5088. void H225_BandwidthReject::PrintOn(ostream & strm) const
  5089. {
  5090.   int indent = strm.precision() + 2;
  5091.   strm << "{\n";
  5092.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  5093.   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
  5094.   strm << setw(indent+19) << "allowedBandWidth = " << setprecision(indent) << m_allowedBandWidth << '\n';
  5095.   if (HasOptionalField(e_nonStandardData))
  5096.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  5097.   if (HasOptionalField(e_altGKInfo))
  5098.     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
  5099.   if (HasOptionalField(e_tokens))
  5100.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  5101.   if (HasOptionalField(e_cryptoTokens))
  5102.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  5103.   if (HasOptionalField(e_integrityCheckValue))
  5104.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  5105.   if (HasOptionalField(e_genericData))
  5106.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  5107.   strm << setw(indent-1) << "}";
  5108. }
  5109. #endif
  5110.  
  5111.  
  5112. PObject::Comparison H225_BandwidthReject::Compare(const PObject & obj) const
  5113. {
  5114. #ifndef PASN_LEANANDMEAN
  5115.   PAssert(IsDescendant(H225_BandwidthReject::Class()), PInvalidCast);
  5116. #endif
  5117.   const H225_BandwidthReject & other = (const H225_BandwidthReject &)obj;
  5118.  
  5119.   Comparison result;
  5120.  
  5121.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  5122.     return result;
  5123.   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
  5124.     return result;
  5125.   if ((result = m_allowedBandWidth.Compare(other.m_allowedBandWidth)) != EqualTo)
  5126.     return result;
  5127.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  5128.     return result;
  5129.  
  5130.   return PASN_Sequence::Compare(other);
  5131. }
  5132.  
  5133.  
  5134. PINDEX H225_BandwidthReject::GetDataLength() const
  5135. {
  5136.   PINDEX length = 0;
  5137.   length += m_requestSeqNum.GetObjectLength();
  5138.   length += m_rejectReason.GetObjectLength();
  5139.   length += m_allowedBandWidth.GetObjectLength();
  5140.   if (HasOptionalField(e_nonStandardData))
  5141.     length += m_nonStandardData.GetObjectLength();
  5142.   return length;
  5143. }
  5144.  
  5145.  
  5146. BOOL H225_BandwidthReject::Decode(PASN_Stream & strm)
  5147. {
  5148.   if (!PreambleDecode(strm))
  5149.     return FALSE;
  5150.  
  5151.   if (!m_requestSeqNum.Decode(strm))
  5152.     return FALSE;
  5153.   if (!m_rejectReason.Decode(strm))
  5154.     return FALSE;
  5155.   if (!m_allowedBandWidth.Decode(strm))
  5156.     return FALSE;
  5157.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  5158.     return FALSE;
  5159.   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
  5160.     return FALSE;
  5161.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  5162.     return FALSE;
  5163.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  5164.     return FALSE;
  5165.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  5166.     return FALSE;
  5167.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  5168.     return FALSE;
  5169.  
  5170.   return UnknownExtensionsDecode(strm);
  5171. }
  5172.  
  5173.  
  5174. void H225_BandwidthReject::Encode(PASN_Stream & strm) const
  5175. {
  5176.   PreambleEncode(strm);
  5177.  
  5178.   m_requestSeqNum.Encode(strm);
  5179.   m_rejectReason.Encode(strm);
  5180.   m_allowedBandWidth.Encode(strm);
  5181.   if (HasOptionalField(e_nonStandardData))
  5182.     m_nonStandardData.Encode(strm);
  5183.   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
  5184.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  5185.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  5186.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  5187.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  5188.  
  5189.   UnknownExtensionsEncode(strm);
  5190. }
  5191.  
  5192.  
  5193. PObject * H225_BandwidthReject::Clone() const
  5194. {
  5195. #ifndef PASN_LEANANDMEAN
  5196.   PAssert(IsClass(H225_BandwidthReject::Class()), PInvalidCast);
  5197. #endif
  5198.   return new H225_BandwidthReject(*this);
  5199. }
  5200.  
  5201.  
  5202. //
  5203. // LocationRequest
  5204. //
  5205.  
  5206. H225_LocationRequest::H225_LocationRequest(unsigned tag, PASN_Object::TagClass tagClass)
  5207.   : PASN_Sequence(tag, tagClass, 2, TRUE, 12)
  5208. {
  5209.   IncludeOptionalField(e_canMapAlias);
  5210.   m_hopCount.SetConstraints(PASN_Object::FixedConstraint, 1, 255);
  5211. }
  5212.  
  5213.  
  5214. #ifndef PASN_NOPRINTON
  5215. void H225_LocationRequest::PrintOn(ostream & strm) const
  5216. {
  5217.   int indent = strm.precision() + 2;
  5218.   strm << "{\n";
  5219.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  5220.   if (HasOptionalField(e_endpointIdentifier))
  5221.     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  5222.   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
  5223.   if (HasOptionalField(e_nonStandardData))
  5224.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  5225.   strm << setw(indent+15) << "replyAddress = " << setprecision(indent) << m_replyAddress << '\n';
  5226.   if (HasOptionalField(e_sourceInfo))
  5227.     strm << setw(indent+13) << "sourceInfo = " << setprecision(indent) << m_sourceInfo << '\n';
  5228.   if (HasOptionalField(e_canMapAlias))
  5229.     strm << setw(indent+14) << "canMapAlias = " << setprecision(indent) << m_canMapAlias << '\n';
  5230.   if (HasOptionalField(e_gatekeeperIdentifier))
  5231.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  5232.   if (HasOptionalField(e_tokens))
  5233.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  5234.   if (HasOptionalField(e_cryptoTokens))
  5235.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  5236.   if (HasOptionalField(e_integrityCheckValue))
  5237.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  5238.   if (HasOptionalField(e_desiredProtocols))
  5239.     strm << setw(indent+19) << "desiredProtocols = " << setprecision(indent) << m_desiredProtocols << '\n';
  5240.   if (HasOptionalField(e_desiredTunnelledProtocol))
  5241.     strm << setw(indent+27) << "desiredTunnelledProtocol = " << setprecision(indent) << m_desiredTunnelledProtocol << '\n';
  5242.   if (HasOptionalField(e_featureSet))
  5243.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  5244.   if (HasOptionalField(e_genericData))
  5245.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  5246.   if (HasOptionalField(e_hopCount))
  5247.     strm << setw(indent+11) << "hopCount = " << setprecision(indent) << m_hopCount << '\n';
  5248.   if (HasOptionalField(e_circuitInfo))
  5249.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  5250.   strm << setw(indent-1) << "}";
  5251. }
  5252. #endif
  5253.  
  5254.  
  5255. PObject::Comparison H225_LocationRequest::Compare(const PObject & obj) const
  5256. {
  5257. #ifndef PASN_LEANANDMEAN
  5258.   PAssert(IsDescendant(H225_LocationRequest::Class()), PInvalidCast);
  5259. #endif
  5260.   const H225_LocationRequest & other = (const H225_LocationRequest &)obj;
  5261.  
  5262.   Comparison result;
  5263.  
  5264.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  5265.     return result;
  5266.   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
  5267.     return result;
  5268.   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
  5269.     return result;
  5270.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  5271.     return result;
  5272.   if ((result = m_replyAddress.Compare(other.m_replyAddress)) != EqualTo)
  5273.     return result;
  5274.  
  5275.   return PASN_Sequence::Compare(other);
  5276. }
  5277.  
  5278.  
  5279. PINDEX H225_LocationRequest::GetDataLength() const
  5280. {
  5281.   PINDEX length = 0;
  5282.   length += m_requestSeqNum.GetObjectLength();
  5283.   if (HasOptionalField(e_endpointIdentifier))
  5284.     length += m_endpointIdentifier.GetObjectLength();
  5285.   length += m_destinationInfo.GetObjectLength();
  5286.   if (HasOptionalField(e_nonStandardData))
  5287.     length += m_nonStandardData.GetObjectLength();
  5288.   length += m_replyAddress.GetObjectLength();
  5289.   return length;
  5290. }
  5291.  
  5292.  
  5293. BOOL H225_LocationRequest::Decode(PASN_Stream & strm)
  5294. {
  5295.   if (!PreambleDecode(strm))
  5296.     return FALSE;
  5297.  
  5298.   if (!m_requestSeqNum.Decode(strm))
  5299.     return FALSE;
  5300.   if (HasOptionalField(e_endpointIdentifier) && !m_endpointIdentifier.Decode(strm))
  5301.     return FALSE;
  5302.   if (!m_destinationInfo.Decode(strm))
  5303.     return FALSE;
  5304.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  5305.     return FALSE;
  5306.   if (!m_replyAddress.Decode(strm))
  5307.     return FALSE;
  5308.   if (!KnownExtensionDecode(strm, e_sourceInfo, m_sourceInfo))
  5309.     return FALSE;
  5310.   if (!KnownExtensionDecode(strm, e_canMapAlias, m_canMapAlias))
  5311.     return FALSE;
  5312.   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
  5313.     return FALSE;
  5314.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  5315.     return FALSE;
  5316.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  5317.     return FALSE;
  5318.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  5319.     return FALSE;
  5320.   if (!KnownExtensionDecode(strm, e_desiredProtocols, m_desiredProtocols))
  5321.     return FALSE;
  5322.   if (!KnownExtensionDecode(strm, e_desiredTunnelledProtocol, m_desiredTunnelledProtocol))
  5323.     return FALSE;
  5324.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  5325.     return FALSE;
  5326.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  5327.     return FALSE;
  5328.   if (!KnownExtensionDecode(strm, e_hopCount, m_hopCount))
  5329.     return FALSE;
  5330.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  5331.     return FALSE;
  5332.  
  5333.   return UnknownExtensionsDecode(strm);
  5334. }
  5335.  
  5336.  
  5337. void H225_LocationRequest::Encode(PASN_Stream & strm) const
  5338. {
  5339.   PreambleEncode(strm);
  5340.  
  5341.   m_requestSeqNum.Encode(strm);
  5342.   if (HasOptionalField(e_endpointIdentifier))
  5343.     m_endpointIdentifier.Encode(strm);
  5344.   m_destinationInfo.Encode(strm);
  5345.   if (HasOptionalField(e_nonStandardData))
  5346.     m_nonStandardData.Encode(strm);
  5347.   m_replyAddress.Encode(strm);
  5348.   KnownExtensionEncode(strm, e_sourceInfo, m_sourceInfo);
  5349.   KnownExtensionEncode(strm, e_canMapAlias, m_canMapAlias);
  5350.   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
  5351.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  5352.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  5353.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  5354.   KnownExtensionEncode(strm, e_desiredProtocols, m_desiredProtocols);
  5355.   KnownExtensionEncode(strm, e_desiredTunnelledProtocol, m_desiredTunnelledProtocol);
  5356.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  5357.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  5358.   KnownExtensionEncode(strm, e_hopCount, m_hopCount);
  5359.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  5360.  
  5361.   UnknownExtensionsEncode(strm);
  5362. }
  5363.  
  5364.  
  5365. PObject * H225_LocationRequest::Clone() const
  5366. {
  5367. #ifndef PASN_LEANANDMEAN
  5368.   PAssert(IsClass(H225_LocationRequest::Class()), PInvalidCast);
  5369. #endif
  5370.   return new H225_LocationRequest(*this);
  5371. }
  5372.  
  5373.  
  5374. //
  5375. // LocationReject
  5376. //
  5377.  
  5378. H225_LocationReject::H225_LocationReject(unsigned tag, PASN_Object::TagClass tagClass)
  5379.   : PASN_Sequence(tag, tagClass, 1, TRUE, 7)
  5380. {
  5381. }
  5382.  
  5383.  
  5384. #ifndef PASN_NOPRINTON
  5385. void H225_LocationReject::PrintOn(ostream & strm) const
  5386. {
  5387.   int indent = strm.precision() + 2;
  5388.   strm << "{\n";
  5389.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  5390.   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
  5391.   if (HasOptionalField(e_nonStandardData))
  5392.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  5393.   if (HasOptionalField(e_altGKInfo))
  5394.     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
  5395.   if (HasOptionalField(e_tokens))
  5396.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  5397.   if (HasOptionalField(e_cryptoTokens))
  5398.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  5399.   if (HasOptionalField(e_integrityCheckValue))
  5400.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  5401.   if (HasOptionalField(e_featureSet))
  5402.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  5403.   if (HasOptionalField(e_genericData))
  5404.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  5405.   if (HasOptionalField(e_serviceControl))
  5406.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  5407.   strm << setw(indent-1) << "}";
  5408. }
  5409. #endif
  5410.  
  5411.  
  5412. PObject::Comparison H225_LocationReject::Compare(const PObject & obj) const
  5413. {
  5414. #ifndef PASN_LEANANDMEAN
  5415.   PAssert(IsDescendant(H225_LocationReject::Class()), PInvalidCast);
  5416. #endif
  5417.   const H225_LocationReject & other = (const H225_LocationReject &)obj;
  5418.  
  5419.   Comparison result;
  5420.  
  5421.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  5422.     return result;
  5423.   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
  5424.     return result;
  5425.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  5426.     return result;
  5427.  
  5428.   return PASN_Sequence::Compare(other);
  5429. }
  5430.  
  5431.  
  5432. PINDEX H225_LocationReject::GetDataLength() const
  5433. {
  5434.   PINDEX length = 0;
  5435.   length += m_requestSeqNum.GetObjectLength();
  5436.   length += m_rejectReason.GetObjectLength();
  5437.   if (HasOptionalField(e_nonStandardData))
  5438.     length += m_nonStandardData.GetObjectLength();
  5439.   return length;
  5440. }
  5441.  
  5442.  
  5443. BOOL H225_LocationReject::Decode(PASN_Stream & strm)
  5444. {
  5445.   if (!PreambleDecode(strm))
  5446.     return FALSE;
  5447.  
  5448.   if (!m_requestSeqNum.Decode(strm))
  5449.     return FALSE;
  5450.   if (!m_rejectReason.Decode(strm))
  5451.     return FALSE;
  5452.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  5453.     return FALSE;
  5454.   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
  5455.     return FALSE;
  5456.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  5457.     return FALSE;
  5458.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  5459.     return FALSE;
  5460.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  5461.     return FALSE;
  5462.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  5463.     return FALSE;
  5464.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  5465.     return FALSE;
  5466.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  5467.     return FALSE;
  5468.  
  5469.   return UnknownExtensionsDecode(strm);
  5470. }
  5471.  
  5472.  
  5473. void H225_LocationReject::Encode(PASN_Stream & strm) const
  5474. {
  5475.   PreambleEncode(strm);
  5476.  
  5477.   m_requestSeqNum.Encode(strm);
  5478.   m_rejectReason.Encode(strm);
  5479.   if (HasOptionalField(e_nonStandardData))
  5480.     m_nonStandardData.Encode(strm);
  5481.   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
  5482.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  5483.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  5484.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  5485.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  5486.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  5487.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  5488.  
  5489.   UnknownExtensionsEncode(strm);
  5490. }
  5491.  
  5492.  
  5493. PObject * H225_LocationReject::Clone() const
  5494. {
  5495. #ifndef PASN_LEANANDMEAN
  5496.   PAssert(IsClass(H225_LocationReject::Class()), PInvalidCast);
  5497. #endif
  5498.   return new H225_LocationReject(*this);
  5499. }
  5500.  
  5501.  
  5502. //
  5503. // DisengageReject
  5504. //
  5505.  
  5506. H225_DisengageReject::H225_DisengageReject(unsigned tag, PASN_Object::TagClass tagClass)
  5507.   : PASN_Sequence(tag, tagClass, 1, TRUE, 5)
  5508. {
  5509. }
  5510.  
  5511.  
  5512. #ifndef PASN_NOPRINTON
  5513. void H225_DisengageReject::PrintOn(ostream & strm) const
  5514. {
  5515.   int indent = strm.precision() + 2;
  5516.   strm << "{\n";
  5517.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  5518.   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
  5519.   if (HasOptionalField(e_nonStandardData))
  5520.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  5521.   if (HasOptionalField(e_altGKInfo))
  5522.     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
  5523.   if (HasOptionalField(e_tokens))
  5524.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  5525.   if (HasOptionalField(e_cryptoTokens))
  5526.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  5527.   if (HasOptionalField(e_integrityCheckValue))
  5528.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  5529.   if (HasOptionalField(e_genericData))
  5530.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  5531.   strm << setw(indent-1) << "}";
  5532. }
  5533. #endif
  5534.  
  5535.  
  5536. PObject::Comparison H225_DisengageReject::Compare(const PObject & obj) const
  5537. {
  5538. #ifndef PASN_LEANANDMEAN
  5539.   PAssert(IsDescendant(H225_DisengageReject::Class()), PInvalidCast);
  5540. #endif
  5541.   const H225_DisengageReject & other = (const H225_DisengageReject &)obj;
  5542.  
  5543.   Comparison result;
  5544.  
  5545.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  5546.     return result;
  5547.   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
  5548.     return result;
  5549.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  5550.     return result;
  5551.  
  5552.   return PASN_Sequence::Compare(other);
  5553. }
  5554.  
  5555.  
  5556. PINDEX H225_DisengageReject::GetDataLength() const
  5557. {
  5558.   PINDEX length = 0;
  5559.   length += m_requestSeqNum.GetObjectLength();
  5560.   length += m_rejectReason.GetObjectLength();
  5561.   if (HasOptionalField(e_nonStandardData))
  5562.     length += m_nonStandardData.GetObjectLength();
  5563.   return length;
  5564. }
  5565.  
  5566.  
  5567. BOOL H225_DisengageReject::Decode(PASN_Stream & strm)
  5568. {
  5569.   if (!PreambleDecode(strm))
  5570.     return FALSE;
  5571.  
  5572.   if (!m_requestSeqNum.Decode(strm))
  5573.     return FALSE;
  5574.   if (!m_rejectReason.Decode(strm))
  5575.     return FALSE;
  5576.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  5577.     return FALSE;
  5578.   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
  5579.     return FALSE;
  5580.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  5581.     return FALSE;
  5582.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  5583.     return FALSE;
  5584.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  5585.     return FALSE;
  5586.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  5587.     return FALSE;
  5588.  
  5589.   return UnknownExtensionsDecode(strm);
  5590. }
  5591.  
  5592.  
  5593. void H225_DisengageReject::Encode(PASN_Stream & strm) const
  5594. {
  5595.   PreambleEncode(strm);
  5596.  
  5597.   m_requestSeqNum.Encode(strm);
  5598.   m_rejectReason.Encode(strm);
  5599.   if (HasOptionalField(e_nonStandardData))
  5600.     m_nonStandardData.Encode(strm);
  5601.   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
  5602.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  5603.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  5604.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  5605.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  5606.  
  5607.   UnknownExtensionsEncode(strm);
  5608. }
  5609.  
  5610.  
  5611. PObject * H225_DisengageReject::Clone() const
  5612. {
  5613. #ifndef PASN_LEANANDMEAN
  5614.   PAssert(IsClass(H225_DisengageReject::Class()), PInvalidCast);
  5615. #endif
  5616.   return new H225_DisengageReject(*this);
  5617. }
  5618.  
  5619.  
  5620. //
  5621. // InfoRequest
  5622. //
  5623.  
  5624. H225_InfoRequest::H225_InfoRequest(unsigned tag, PASN_Object::TagClass tagClass)
  5625.   : PASN_Sequence(tag, tagClass, 2, TRUE, 11)
  5626. {
  5627.   IncludeOptionalField(e_callIdentifier);
  5628.   m_nextSegmentRequested.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  5629. }
  5630.  
  5631.  
  5632. #ifndef PASN_NOPRINTON
  5633. void H225_InfoRequest::PrintOn(ostream & strm) const
  5634. {
  5635.   int indent = strm.precision() + 2;
  5636.   strm << "{\n";
  5637.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  5638.   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
  5639.   if (HasOptionalField(e_nonStandardData))
  5640.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  5641.   if (HasOptionalField(e_replyAddress))
  5642.     strm << setw(indent+15) << "replyAddress = " << setprecision(indent) << m_replyAddress << '\n';
  5643.   if (HasOptionalField(e_callIdentifier))
  5644.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  5645.   if (HasOptionalField(e_tokens))
  5646.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  5647.   if (HasOptionalField(e_cryptoTokens))
  5648.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  5649.   if (HasOptionalField(e_integrityCheckValue))
  5650.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  5651.   if (HasOptionalField(e_uuiesRequested))
  5652.     strm << setw(indent+17) << "uuiesRequested = " << setprecision(indent) << m_uuiesRequested << '\n';
  5653.   if (HasOptionalField(e_callLinkage))
  5654.     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
  5655.   if (HasOptionalField(e_usageInfoRequested))
  5656.     strm << setw(indent+21) << "usageInfoRequested = " << setprecision(indent) << m_usageInfoRequested << '\n';
  5657.   if (HasOptionalField(e_segmentedResponseSupported))
  5658.     strm << setw(indent+29) << "segmentedResponseSupported = " << setprecision(indent) << m_segmentedResponseSupported << '\n';
  5659.   if (HasOptionalField(e_nextSegmentRequested))
  5660.     strm << setw(indent+23) << "nextSegmentRequested = " << setprecision(indent) << m_nextSegmentRequested << '\n';
  5661.   if (HasOptionalField(e_capacityInfoRequested))
  5662.     strm << setw(indent+24) << "capacityInfoRequested = " << setprecision(indent) << m_capacityInfoRequested << '\n';
  5663.   if (HasOptionalField(e_genericData))
  5664.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  5665.   strm << setw(indent-1) << "}";
  5666. }
  5667. #endif
  5668.  
  5669.  
  5670. PObject::Comparison H225_InfoRequest::Compare(const PObject & obj) const
  5671. {
  5672. #ifndef PASN_LEANANDMEAN
  5673.   PAssert(IsDescendant(H225_InfoRequest::Class()), PInvalidCast);
  5674. #endif
  5675.   const H225_InfoRequest & other = (const H225_InfoRequest &)obj;
  5676.  
  5677.   Comparison result;
  5678.  
  5679.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  5680.     return result;
  5681.   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
  5682.     return result;
  5683.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  5684.     return result;
  5685.   if ((result = m_replyAddress.Compare(other.m_replyAddress)) != EqualTo)
  5686.     return result;
  5687.  
  5688.   return PASN_Sequence::Compare(other);
  5689. }
  5690.  
  5691.  
  5692. PINDEX H225_InfoRequest::GetDataLength() const
  5693. {
  5694.   PINDEX length = 0;
  5695.   length += m_requestSeqNum.GetObjectLength();
  5696.   length += m_callReferenceValue.GetObjectLength();
  5697.   if (HasOptionalField(e_nonStandardData))
  5698.     length += m_nonStandardData.GetObjectLength();
  5699.   if (HasOptionalField(e_replyAddress))
  5700.     length += m_replyAddress.GetObjectLength();
  5701.   return length;
  5702. }
  5703.  
  5704.  
  5705. BOOL H225_InfoRequest::Decode(PASN_Stream & strm)
  5706. {
  5707.   if (!PreambleDecode(strm))
  5708.     return FALSE;
  5709.  
  5710.   if (!m_requestSeqNum.Decode(strm))
  5711.     return FALSE;
  5712.   if (!m_callReferenceValue.Decode(strm))
  5713.     return FALSE;
  5714.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  5715.     return FALSE;
  5716.   if (HasOptionalField(e_replyAddress) && !m_replyAddress.Decode(strm))
  5717.     return FALSE;
  5718.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  5719.     return FALSE;
  5720.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  5721.     return FALSE;
  5722.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  5723.     return FALSE;
  5724.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  5725.     return FALSE;
  5726.   if (!KnownExtensionDecode(strm, e_uuiesRequested, m_uuiesRequested))
  5727.     return FALSE;
  5728.   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
  5729.     return FALSE;
  5730.   if (!KnownExtensionDecode(strm, e_usageInfoRequested, m_usageInfoRequested))
  5731.     return FALSE;
  5732.   if (!KnownExtensionDecode(strm, e_segmentedResponseSupported, m_segmentedResponseSupported))
  5733.     return FALSE;
  5734.   if (!KnownExtensionDecode(strm, e_nextSegmentRequested, m_nextSegmentRequested))
  5735.     return FALSE;
  5736.   if (!KnownExtensionDecode(strm, e_capacityInfoRequested, m_capacityInfoRequested))
  5737.     return FALSE;
  5738.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  5739.     return FALSE;
  5740.  
  5741.   return UnknownExtensionsDecode(strm);
  5742. }
  5743.  
  5744.  
  5745. void H225_InfoRequest::Encode(PASN_Stream & strm) const
  5746. {
  5747.   PreambleEncode(strm);
  5748.  
  5749.   m_requestSeqNum.Encode(strm);
  5750.   m_callReferenceValue.Encode(strm);
  5751.   if (HasOptionalField(e_nonStandardData))
  5752.     m_nonStandardData.Encode(strm);
  5753.   if (HasOptionalField(e_replyAddress))
  5754.     m_replyAddress.Encode(strm);
  5755.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  5756.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  5757.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  5758.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  5759.   KnownExtensionEncode(strm, e_uuiesRequested, m_uuiesRequested);
  5760.   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
  5761.   KnownExtensionEncode(strm, e_usageInfoRequested, m_usageInfoRequested);
  5762.   KnownExtensionEncode(strm, e_segmentedResponseSupported, m_segmentedResponseSupported);
  5763.   KnownExtensionEncode(strm, e_nextSegmentRequested, m_nextSegmentRequested);
  5764.   KnownExtensionEncode(strm, e_capacityInfoRequested, m_capacityInfoRequested);
  5765.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  5766.  
  5767.   UnknownExtensionsEncode(strm);
  5768. }
  5769.  
  5770.  
  5771. PObject * H225_InfoRequest::Clone() const
  5772. {
  5773. #ifndef PASN_LEANANDMEAN
  5774.   PAssert(IsClass(H225_InfoRequest::Class()), PInvalidCast);
  5775. #endif
  5776.   return new H225_InfoRequest(*this);
  5777. }
  5778.  
  5779.  
  5780. //
  5781. // InfoRequestAck
  5782. //
  5783.  
  5784. H225_InfoRequestAck::H225_InfoRequestAck(unsigned tag, PASN_Object::TagClass tagClass)
  5785.   : PASN_Sequence(tag, tagClass, 4, TRUE, 0)
  5786. {
  5787. }
  5788.  
  5789.  
  5790. #ifndef PASN_NOPRINTON
  5791. void H225_InfoRequestAck::PrintOn(ostream & strm) const
  5792. {
  5793.   int indent = strm.precision() + 2;
  5794.   strm << "{\n";
  5795.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  5796.   if (HasOptionalField(e_nonStandardData))
  5797.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  5798.   if (HasOptionalField(e_tokens))
  5799.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  5800.   if (HasOptionalField(e_cryptoTokens))
  5801.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  5802.   if (HasOptionalField(e_integrityCheckValue))
  5803.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  5804.   strm << setw(indent-1) << "}";
  5805. }
  5806. #endif
  5807.  
  5808.  
  5809. PObject::Comparison H225_InfoRequestAck::Compare(const PObject & obj) const
  5810. {
  5811. #ifndef PASN_LEANANDMEAN
  5812.   PAssert(IsDescendant(H225_InfoRequestAck::Class()), PInvalidCast);
  5813. #endif
  5814.   const H225_InfoRequestAck & other = (const H225_InfoRequestAck &)obj;
  5815.  
  5816.   Comparison result;
  5817.  
  5818.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  5819.     return result;
  5820.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  5821.     return result;
  5822.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  5823.     return result;
  5824.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  5825.     return result;
  5826.   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
  5827.     return result;
  5828.  
  5829.   return PASN_Sequence::Compare(other);
  5830. }
  5831.  
  5832.  
  5833. PINDEX H225_InfoRequestAck::GetDataLength() const
  5834. {
  5835.   PINDEX length = 0;
  5836.   length += m_requestSeqNum.GetObjectLength();
  5837.   if (HasOptionalField(e_nonStandardData))
  5838.     length += m_nonStandardData.GetObjectLength();
  5839.   if (HasOptionalField(e_tokens))
  5840.     length += m_tokens.GetObjectLength();
  5841.   if (HasOptionalField(e_cryptoTokens))
  5842.     length += m_cryptoTokens.GetObjectLength();
  5843.   if (HasOptionalField(e_integrityCheckValue))
  5844.     length += m_integrityCheckValue.GetObjectLength();
  5845.   return length;
  5846. }
  5847.  
  5848.  
  5849. BOOL H225_InfoRequestAck::Decode(PASN_Stream & strm)
  5850. {
  5851.   if (!PreambleDecode(strm))
  5852.     return FALSE;
  5853.  
  5854.   if (!m_requestSeqNum.Decode(strm))
  5855.     return FALSE;
  5856.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  5857.     return FALSE;
  5858.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  5859.     return FALSE;
  5860.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  5861.     return FALSE;
  5862.   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
  5863.     return FALSE;
  5864.  
  5865.   return UnknownExtensionsDecode(strm);
  5866. }
  5867.  
  5868.  
  5869. void H225_InfoRequestAck::Encode(PASN_Stream & strm) const
  5870. {
  5871.   PreambleEncode(strm);
  5872.  
  5873.   m_requestSeqNum.Encode(strm);
  5874.   if (HasOptionalField(e_nonStandardData))
  5875.     m_nonStandardData.Encode(strm);
  5876.   if (HasOptionalField(e_tokens))
  5877.     m_tokens.Encode(strm);
  5878.   if (HasOptionalField(e_cryptoTokens))
  5879.     m_cryptoTokens.Encode(strm);
  5880.   if (HasOptionalField(e_integrityCheckValue))
  5881.     m_integrityCheckValue.Encode(strm);
  5882.  
  5883.   UnknownExtensionsEncode(strm);
  5884. }
  5885.  
  5886.  
  5887. PObject * H225_InfoRequestAck::Clone() const
  5888. {
  5889. #ifndef PASN_LEANANDMEAN
  5890.   PAssert(IsClass(H225_InfoRequestAck::Class()), PInvalidCast);
  5891. #endif
  5892.   return new H225_InfoRequestAck(*this);
  5893. }
  5894.  
  5895.  
  5896. //
  5897. // InfoRequestNak
  5898. //
  5899.  
  5900. H225_InfoRequestNak::H225_InfoRequestNak(unsigned tag, PASN_Object::TagClass tagClass)
  5901.   : PASN_Sequence(tag, tagClass, 5, TRUE, 0)
  5902. {
  5903. }
  5904.  
  5905.  
  5906. #ifndef PASN_NOPRINTON
  5907. void H225_InfoRequestNak::PrintOn(ostream & strm) const
  5908. {
  5909.   int indent = strm.precision() + 2;
  5910.   strm << "{\n";
  5911.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  5912.   if (HasOptionalField(e_nonStandardData))
  5913.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  5914.   strm << setw(indent+12) << "nakReason = " << setprecision(indent) << m_nakReason << '\n';
  5915.   if (HasOptionalField(e_altGKInfo))
  5916.     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
  5917.   if (HasOptionalField(e_tokens))
  5918.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  5919.   if (HasOptionalField(e_cryptoTokens))
  5920.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  5921.   if (HasOptionalField(e_integrityCheckValue))
  5922.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  5923.   strm << setw(indent-1) << "}";
  5924. }
  5925. #endif
  5926.  
  5927.  
  5928. PObject::Comparison H225_InfoRequestNak::Compare(const PObject & obj) const
  5929. {
  5930. #ifndef PASN_LEANANDMEAN
  5931.   PAssert(IsDescendant(H225_InfoRequestNak::Class()), PInvalidCast);
  5932. #endif
  5933.   const H225_InfoRequestNak & other = (const H225_InfoRequestNak &)obj;
  5934.  
  5935.   Comparison result;
  5936.  
  5937.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  5938.     return result;
  5939.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  5940.     return result;
  5941.   if ((result = m_nakReason.Compare(other.m_nakReason)) != EqualTo)
  5942.     return result;
  5943.   if ((result = m_altGKInfo.Compare(other.m_altGKInfo)) != EqualTo)
  5944.     return result;
  5945.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  5946.     return result;
  5947.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  5948.     return result;
  5949.   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
  5950.     return result;
  5951.  
  5952.   return PASN_Sequence::Compare(other);
  5953. }
  5954.  
  5955.  
  5956. PINDEX H225_InfoRequestNak::GetDataLength() const
  5957. {
  5958.   PINDEX length = 0;
  5959.   length += m_requestSeqNum.GetObjectLength();
  5960.   if (HasOptionalField(e_nonStandardData))
  5961.     length += m_nonStandardData.GetObjectLength();
  5962.   length += m_nakReason.GetObjectLength();
  5963.   if (HasOptionalField(e_altGKInfo))
  5964.     length += m_altGKInfo.GetObjectLength();
  5965.   if (HasOptionalField(e_tokens))
  5966.     length += m_tokens.GetObjectLength();
  5967.   if (HasOptionalField(e_cryptoTokens))
  5968.     length += m_cryptoTokens.GetObjectLength();
  5969.   if (HasOptionalField(e_integrityCheckValue))
  5970.     length += m_integrityCheckValue.GetObjectLength();
  5971.   return length;
  5972. }
  5973.  
  5974.  
  5975. BOOL H225_InfoRequestNak::Decode(PASN_Stream & strm)
  5976. {
  5977.   if (!PreambleDecode(strm))
  5978.     return FALSE;
  5979.  
  5980.   if (!m_requestSeqNum.Decode(strm))
  5981.     return FALSE;
  5982.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  5983.     return FALSE;
  5984.   if (!m_nakReason.Decode(strm))
  5985.     return FALSE;
  5986.   if (HasOptionalField(e_altGKInfo) && !m_altGKInfo.Decode(strm))
  5987.     return FALSE;
  5988.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  5989.     return FALSE;
  5990.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  5991.     return FALSE;
  5992.   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
  5993.     return FALSE;
  5994.  
  5995.   return UnknownExtensionsDecode(strm);
  5996. }
  5997.  
  5998.  
  5999. void H225_InfoRequestNak::Encode(PASN_Stream & strm) const
  6000. {
  6001.   PreambleEncode(strm);
  6002.  
  6003.   m_requestSeqNum.Encode(strm);
  6004.   if (HasOptionalField(e_nonStandardData))
  6005.     m_nonStandardData.Encode(strm);
  6006.   m_nakReason.Encode(strm);
  6007.   if (HasOptionalField(e_altGKInfo))
  6008.     m_altGKInfo.Encode(strm);
  6009.   if (HasOptionalField(e_tokens))
  6010.     m_tokens.Encode(strm);
  6011.   if (HasOptionalField(e_cryptoTokens))
  6012.     m_cryptoTokens.Encode(strm);
  6013.   if (HasOptionalField(e_integrityCheckValue))
  6014.     m_integrityCheckValue.Encode(strm);
  6015.  
  6016.   UnknownExtensionsEncode(strm);
  6017. }
  6018.  
  6019.  
  6020. PObject * H225_InfoRequestNak::Clone() const
  6021. {
  6022. #ifndef PASN_LEANANDMEAN
  6023.   PAssert(IsClass(H225_InfoRequestNak::Class()), PInvalidCast);
  6024. #endif
  6025.   return new H225_InfoRequestNak(*this);
  6026. }
  6027.  
  6028.  
  6029. //
  6030. // NonStandardMessage
  6031. //
  6032.  
  6033. H225_NonStandardMessage::H225_NonStandardMessage(unsigned tag, PASN_Object::TagClass tagClass)
  6034.   : PASN_Sequence(tag, tagClass, 0, TRUE, 5)
  6035. {
  6036. }
  6037.  
  6038.  
  6039. #ifndef PASN_NOPRINTON
  6040. void H225_NonStandardMessage::PrintOn(ostream & strm) const
  6041. {
  6042.   int indent = strm.precision() + 2;
  6043.   strm << "{\n";
  6044.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  6045.   strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  6046.   if (HasOptionalField(e_tokens))
  6047.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  6048.   if (HasOptionalField(e_cryptoTokens))
  6049.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  6050.   if (HasOptionalField(e_integrityCheckValue))
  6051.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  6052.   if (HasOptionalField(e_featureSet))
  6053.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  6054.   if (HasOptionalField(e_genericData))
  6055.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  6056.   strm << setw(indent-1) << "}";
  6057. }
  6058. #endif
  6059.  
  6060.  
  6061. PObject::Comparison H225_NonStandardMessage::Compare(const PObject & obj) const
  6062. {
  6063. #ifndef PASN_LEANANDMEAN
  6064.   PAssert(IsDescendant(H225_NonStandardMessage::Class()), PInvalidCast);
  6065. #endif
  6066.   const H225_NonStandardMessage & other = (const H225_NonStandardMessage &)obj;
  6067.  
  6068.   Comparison result;
  6069.  
  6070.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  6071.     return result;
  6072.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  6073.     return result;
  6074.  
  6075.   return PASN_Sequence::Compare(other);
  6076. }
  6077.  
  6078.  
  6079. PINDEX H225_NonStandardMessage::GetDataLength() const
  6080. {
  6081.   PINDEX length = 0;
  6082.   length += m_requestSeqNum.GetObjectLength();
  6083.   length += m_nonStandardData.GetObjectLength();
  6084.   return length;
  6085. }
  6086.  
  6087.  
  6088. BOOL H225_NonStandardMessage::Decode(PASN_Stream & strm)
  6089. {
  6090.   if (!PreambleDecode(strm))
  6091.     return FALSE;
  6092.  
  6093.   if (!m_requestSeqNum.Decode(strm))
  6094.     return FALSE;
  6095.   if (!m_nonStandardData.Decode(strm))
  6096.     return FALSE;
  6097.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  6098.     return FALSE;
  6099.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  6100.     return FALSE;
  6101.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  6102.     return FALSE;
  6103.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  6104.     return FALSE;
  6105.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  6106.     return FALSE;
  6107.  
  6108.   return UnknownExtensionsDecode(strm);
  6109. }
  6110.  
  6111.  
  6112. void H225_NonStandardMessage::Encode(PASN_Stream & strm) const
  6113. {
  6114.   PreambleEncode(strm);
  6115.  
  6116.   m_requestSeqNum.Encode(strm);
  6117.   m_nonStandardData.Encode(strm);
  6118.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  6119.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  6120.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  6121.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  6122.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  6123.  
  6124.   UnknownExtensionsEncode(strm);
  6125. }
  6126.  
  6127.  
  6128. PObject * H225_NonStandardMessage::Clone() const
  6129. {
  6130. #ifndef PASN_LEANANDMEAN
  6131.   PAssert(IsClass(H225_NonStandardMessage::Class()), PInvalidCast);
  6132. #endif
  6133.   return new H225_NonStandardMessage(*this);
  6134. }
  6135.  
  6136.  
  6137. //
  6138. // UnknownMessageResponse
  6139. //
  6140.  
  6141. H225_UnknownMessageResponse::H225_UnknownMessageResponse(unsigned tag, PASN_Object::TagClass tagClass)
  6142.   : PASN_Sequence(tag, tagClass, 0, TRUE, 4)
  6143. {
  6144.   IncludeOptionalField(e_messageNotUnderstood);
  6145. }
  6146.  
  6147.  
  6148. #ifndef PASN_NOPRINTON
  6149. void H225_UnknownMessageResponse::PrintOn(ostream & strm) const
  6150. {
  6151.   int indent = strm.precision() + 2;
  6152.   strm << "{\n";
  6153.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  6154.   if (HasOptionalField(e_tokens))
  6155.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  6156.   if (HasOptionalField(e_cryptoTokens))
  6157.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  6158.   if (HasOptionalField(e_integrityCheckValue))
  6159.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  6160.   if (HasOptionalField(e_messageNotUnderstood))
  6161.     strm << setw(indent+23) << "messageNotUnderstood = " << setprecision(indent) << m_messageNotUnderstood << '\n';
  6162.   strm << setw(indent-1) << "}";
  6163. }
  6164. #endif
  6165.  
  6166.  
  6167. PObject::Comparison H225_UnknownMessageResponse::Compare(const PObject & obj) const
  6168. {
  6169. #ifndef PASN_LEANANDMEAN
  6170.   PAssert(IsDescendant(H225_UnknownMessageResponse::Class()), PInvalidCast);
  6171. #endif
  6172.   const H225_UnknownMessageResponse & other = (const H225_UnknownMessageResponse &)obj;
  6173.  
  6174.   Comparison result;
  6175.  
  6176.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  6177.     return result;
  6178.  
  6179.   return PASN_Sequence::Compare(other);
  6180. }
  6181.  
  6182.  
  6183. PINDEX H225_UnknownMessageResponse::GetDataLength() const
  6184. {
  6185.   PINDEX length = 0;
  6186.   length += m_requestSeqNum.GetObjectLength();
  6187.   return length;
  6188. }
  6189.  
  6190.  
  6191. BOOL H225_UnknownMessageResponse::Decode(PASN_Stream & strm)
  6192. {
  6193.   if (!PreambleDecode(strm))
  6194.     return FALSE;
  6195.  
  6196.   if (!m_requestSeqNum.Decode(strm))
  6197.     return FALSE;
  6198.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  6199.     return FALSE;
  6200.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  6201.     return FALSE;
  6202.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  6203.     return FALSE;
  6204.   if (!KnownExtensionDecode(strm, e_messageNotUnderstood, m_messageNotUnderstood))
  6205.     return FALSE;
  6206.  
  6207.   return UnknownExtensionsDecode(strm);
  6208. }
  6209.  
  6210.  
  6211. void H225_UnknownMessageResponse::Encode(PASN_Stream & strm) const
  6212. {
  6213.   PreambleEncode(strm);
  6214.  
  6215.   m_requestSeqNum.Encode(strm);
  6216.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  6217.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  6218.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  6219.   KnownExtensionEncode(strm, e_messageNotUnderstood, m_messageNotUnderstood);
  6220.  
  6221.   UnknownExtensionsEncode(strm);
  6222. }
  6223.  
  6224.  
  6225. PObject * H225_UnknownMessageResponse::Clone() const
  6226. {
  6227. #ifndef PASN_LEANANDMEAN
  6228.   PAssert(IsClass(H225_UnknownMessageResponse::Class()), PInvalidCast);
  6229. #endif
  6230.   return new H225_UnknownMessageResponse(*this);
  6231. }
  6232.  
  6233.  
  6234. //
  6235. // RequestInProgress
  6236. //
  6237.  
  6238. H225_RequestInProgress::H225_RequestInProgress(unsigned tag, PASN_Object::TagClass tagClass)
  6239.   : PASN_Sequence(tag, tagClass, 4, TRUE, 0)
  6240. {
  6241.   m_delay.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
  6242. }
  6243.  
  6244.  
  6245. #ifndef PASN_NOPRINTON
  6246. void H225_RequestInProgress::PrintOn(ostream & strm) const
  6247. {
  6248.   int indent = strm.precision() + 2;
  6249.   strm << "{\n";
  6250.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  6251.   if (HasOptionalField(e_nonStandardData))
  6252.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  6253.   if (HasOptionalField(e_tokens))
  6254.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  6255.   if (HasOptionalField(e_cryptoTokens))
  6256.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  6257.   if (HasOptionalField(e_integrityCheckValue))
  6258.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  6259.   strm << setw(indent+8) << "delay = " << setprecision(indent) << m_delay << '\n';
  6260.   strm << setw(indent-1) << "}";
  6261. }
  6262. #endif
  6263.  
  6264.  
  6265. PObject::Comparison H225_RequestInProgress::Compare(const PObject & obj) const
  6266. {
  6267. #ifndef PASN_LEANANDMEAN
  6268.   PAssert(IsDescendant(H225_RequestInProgress::Class()), PInvalidCast);
  6269. #endif
  6270.   const H225_RequestInProgress & other = (const H225_RequestInProgress &)obj;
  6271.  
  6272.   Comparison result;
  6273.  
  6274.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  6275.     return result;
  6276.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  6277.     return result;
  6278.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  6279.     return result;
  6280.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  6281.     return result;
  6282.   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
  6283.     return result;
  6284.   if ((result = m_delay.Compare(other.m_delay)) != EqualTo)
  6285.     return result;
  6286.  
  6287.   return PASN_Sequence::Compare(other);
  6288. }
  6289.  
  6290.  
  6291. PINDEX H225_RequestInProgress::GetDataLength() const
  6292. {
  6293.   PINDEX length = 0;
  6294.   length += m_requestSeqNum.GetObjectLength();
  6295.   if (HasOptionalField(e_nonStandardData))
  6296.     length += m_nonStandardData.GetObjectLength();
  6297.   if (HasOptionalField(e_tokens))
  6298.     length += m_tokens.GetObjectLength();
  6299.   if (HasOptionalField(e_cryptoTokens))
  6300.     length += m_cryptoTokens.GetObjectLength();
  6301.   if (HasOptionalField(e_integrityCheckValue))
  6302.     length += m_integrityCheckValue.GetObjectLength();
  6303.   length += m_delay.GetObjectLength();
  6304.   return length;
  6305. }
  6306.  
  6307.  
  6308. BOOL H225_RequestInProgress::Decode(PASN_Stream & strm)
  6309. {
  6310.   if (!PreambleDecode(strm))
  6311.     return FALSE;
  6312.  
  6313.   if (!m_requestSeqNum.Decode(strm))
  6314.     return FALSE;
  6315.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  6316.     return FALSE;
  6317.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  6318.     return FALSE;
  6319.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  6320.     return FALSE;
  6321.   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
  6322.     return FALSE;
  6323.   if (!m_delay.Decode(strm))
  6324.     return FALSE;
  6325.  
  6326.   return UnknownExtensionsDecode(strm);
  6327. }
  6328.  
  6329.  
  6330. void H225_RequestInProgress::Encode(PASN_Stream & strm) const
  6331. {
  6332.   PreambleEncode(strm);
  6333.  
  6334.   m_requestSeqNum.Encode(strm);
  6335.   if (HasOptionalField(e_nonStandardData))
  6336.     m_nonStandardData.Encode(strm);
  6337.   if (HasOptionalField(e_tokens))
  6338.     m_tokens.Encode(strm);
  6339.   if (HasOptionalField(e_cryptoTokens))
  6340.     m_cryptoTokens.Encode(strm);
  6341.   if (HasOptionalField(e_integrityCheckValue))
  6342.     m_integrityCheckValue.Encode(strm);
  6343.   m_delay.Encode(strm);
  6344.  
  6345.   UnknownExtensionsEncode(strm);
  6346. }
  6347.  
  6348.  
  6349. PObject * H225_RequestInProgress::Clone() const
  6350. {
  6351. #ifndef PASN_LEANANDMEAN
  6352.   PAssert(IsClass(H225_RequestInProgress::Class()), PInvalidCast);
  6353. #endif
  6354.   return new H225_RequestInProgress(*this);
  6355. }
  6356.  
  6357.  
  6358. //
  6359. // ResourcesAvailableConfirm
  6360. //
  6361.  
  6362. H225_ResourcesAvailableConfirm::H225_ResourcesAvailableConfirm(unsigned tag, PASN_Object::TagClass tagClass)
  6363.   : PASN_Sequence(tag, tagClass, 4, TRUE, 1)
  6364. {
  6365. }
  6366.  
  6367.  
  6368. #ifndef PASN_NOPRINTON
  6369. void H225_ResourcesAvailableConfirm::PrintOn(ostream & strm) const
  6370. {
  6371.   int indent = strm.precision() + 2;
  6372.   strm << "{\n";
  6373.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  6374.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  6375.   if (HasOptionalField(e_nonStandardData))
  6376.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  6377.   if (HasOptionalField(e_tokens))
  6378.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  6379.   if (HasOptionalField(e_cryptoTokens))
  6380.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  6381.   if (HasOptionalField(e_integrityCheckValue))
  6382.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  6383.   if (HasOptionalField(e_genericData))
  6384.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  6385.   strm << setw(indent-1) << "}";
  6386. }
  6387. #endif
  6388.  
  6389.  
  6390. PObject::Comparison H225_ResourcesAvailableConfirm::Compare(const PObject & obj) const
  6391. {
  6392. #ifndef PASN_LEANANDMEAN
  6393.   PAssert(IsDescendant(H225_ResourcesAvailableConfirm::Class()), PInvalidCast);
  6394. #endif
  6395.   const H225_ResourcesAvailableConfirm & other = (const H225_ResourcesAvailableConfirm &)obj;
  6396.  
  6397.   Comparison result;
  6398.  
  6399.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  6400.     return result;
  6401.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  6402.     return result;
  6403.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  6404.     return result;
  6405.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  6406.     return result;
  6407.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  6408.     return result;
  6409.   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
  6410.     return result;
  6411.  
  6412.   return PASN_Sequence::Compare(other);
  6413. }
  6414.  
  6415.  
  6416. PINDEX H225_ResourcesAvailableConfirm::GetDataLength() const
  6417. {
  6418.   PINDEX length = 0;
  6419.   length += m_requestSeqNum.GetObjectLength();
  6420.   length += m_protocolIdentifier.GetObjectLength();
  6421.   if (HasOptionalField(e_nonStandardData))
  6422.     length += m_nonStandardData.GetObjectLength();
  6423.   if (HasOptionalField(e_tokens))
  6424.     length += m_tokens.GetObjectLength();
  6425.   if (HasOptionalField(e_cryptoTokens))
  6426.     length += m_cryptoTokens.GetObjectLength();
  6427.   if (HasOptionalField(e_integrityCheckValue))
  6428.     length += m_integrityCheckValue.GetObjectLength();
  6429.   return length;
  6430. }
  6431.  
  6432.  
  6433. BOOL H225_ResourcesAvailableConfirm::Decode(PASN_Stream & strm)
  6434. {
  6435.   if (!PreambleDecode(strm))
  6436.     return FALSE;
  6437.  
  6438.   if (!m_requestSeqNum.Decode(strm))
  6439.     return FALSE;
  6440.   if (!m_protocolIdentifier.Decode(strm))
  6441.     return FALSE;
  6442.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  6443.     return FALSE;
  6444.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  6445.     return FALSE;
  6446.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  6447.     return FALSE;
  6448.   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
  6449.     return FALSE;
  6450.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  6451.     return FALSE;
  6452.  
  6453.   return UnknownExtensionsDecode(strm);
  6454. }
  6455.  
  6456.  
  6457. void H225_ResourcesAvailableConfirm::Encode(PASN_Stream & strm) const
  6458. {
  6459.   PreambleEncode(strm);
  6460.  
  6461.   m_requestSeqNum.Encode(strm);
  6462.   m_protocolIdentifier.Encode(strm);
  6463.   if (HasOptionalField(e_nonStandardData))
  6464.     m_nonStandardData.Encode(strm);
  6465.   if (HasOptionalField(e_tokens))
  6466.     m_tokens.Encode(strm);
  6467.   if (HasOptionalField(e_cryptoTokens))
  6468.     m_cryptoTokens.Encode(strm);
  6469.   if (HasOptionalField(e_integrityCheckValue))
  6470.     m_integrityCheckValue.Encode(strm);
  6471.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  6472.  
  6473.   UnknownExtensionsEncode(strm);
  6474. }
  6475.  
  6476.  
  6477. PObject * H225_ResourcesAvailableConfirm::Clone() const
  6478. {
  6479. #ifndef PASN_LEANANDMEAN
  6480.   PAssert(IsClass(H225_ResourcesAvailableConfirm::Class()), PInvalidCast);
  6481. #endif
  6482.   return new H225_ResourcesAvailableConfirm(*this);
  6483. }
  6484.  
  6485.  
  6486. //
  6487. // ServiceControlIndication
  6488. //
  6489.  
  6490. H225_ServiceControlIndication::H225_ServiceControlIndication(unsigned tag, PASN_Object::TagClass tagClass)
  6491.   : PASN_Sequence(tag, tagClass, 8, TRUE, 0)
  6492. {
  6493. }
  6494.  
  6495.  
  6496. #ifndef PASN_NOPRINTON
  6497. void H225_ServiceControlIndication::PrintOn(ostream & strm) const
  6498. {
  6499.   int indent = strm.precision() + 2;
  6500.   strm << "{\n";
  6501.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  6502.   if (HasOptionalField(e_nonStandardData))
  6503.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  6504.   strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  6505.   if (HasOptionalField(e_endpointIdentifier))
  6506.     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  6507.   if (HasOptionalField(e_callSpecific))
  6508.     strm << setw(indent+15) << "callSpecific = " << setprecision(indent) << m_callSpecific << '\n';
  6509.   if (HasOptionalField(e_tokens))
  6510.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  6511.   if (HasOptionalField(e_cryptoTokens))
  6512.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  6513.   if (HasOptionalField(e_integrityCheckValue))
  6514.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  6515.   if (HasOptionalField(e_featureSet))
  6516.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  6517.   if (HasOptionalField(e_genericData))
  6518.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  6519.   strm << setw(indent-1) << "}";
  6520. }
  6521. #endif
  6522.  
  6523.  
  6524. PObject::Comparison H225_ServiceControlIndication::Compare(const PObject & obj) const
  6525. {
  6526. #ifndef PASN_LEANANDMEAN
  6527.   PAssert(IsDescendant(H225_ServiceControlIndication::Class()), PInvalidCast);
  6528. #endif
  6529.   const H225_ServiceControlIndication & other = (const H225_ServiceControlIndication &)obj;
  6530.  
  6531.   Comparison result;
  6532.  
  6533.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  6534.     return result;
  6535.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  6536.     return result;
  6537.   if ((result = m_serviceControl.Compare(other.m_serviceControl)) != EqualTo)
  6538.     return result;
  6539.   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
  6540.     return result;
  6541.   if ((result = m_callSpecific.Compare(other.m_callSpecific)) != EqualTo)
  6542.     return result;
  6543.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  6544.     return result;
  6545.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  6546.     return result;
  6547.   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
  6548.     return result;
  6549.   if ((result = m_featureSet.Compare(other.m_featureSet)) != EqualTo)
  6550.     return result;
  6551.   if ((result = m_genericData.Compare(other.m_genericData)) != EqualTo)
  6552.     return result;
  6553.  
  6554.   return PASN_Sequence::Compare(other);
  6555. }
  6556.  
  6557.  
  6558. PINDEX H225_ServiceControlIndication::GetDataLength() const
  6559. {
  6560.   PINDEX length = 0;
  6561.   length += m_requestSeqNum.GetObjectLength();
  6562.   if (HasOptionalField(e_nonStandardData))
  6563.     length += m_nonStandardData.GetObjectLength();
  6564.   length += m_serviceControl.GetObjectLength();
  6565.   if (HasOptionalField(e_endpointIdentifier))
  6566.     length += m_endpointIdentifier.GetObjectLength();
  6567.   if (HasOptionalField(e_callSpecific))
  6568.     length += m_callSpecific.GetObjectLength();
  6569.   if (HasOptionalField(e_tokens))
  6570.     length += m_tokens.GetObjectLength();
  6571.   if (HasOptionalField(e_cryptoTokens))
  6572.     length += m_cryptoTokens.GetObjectLength();
  6573.   if (HasOptionalField(e_integrityCheckValue))
  6574.     length += m_integrityCheckValue.GetObjectLength();
  6575.   if (HasOptionalField(e_featureSet))
  6576.     length += m_featureSet.GetObjectLength();
  6577.   if (HasOptionalField(e_genericData))
  6578.     length += m_genericData.GetObjectLength();
  6579.   return length;
  6580. }
  6581.  
  6582.  
  6583. BOOL H225_ServiceControlIndication::Decode(PASN_Stream & strm)
  6584. {
  6585.   if (!PreambleDecode(strm))
  6586.     return FALSE;
  6587.  
  6588.   if (!m_requestSeqNum.Decode(strm))
  6589.     return FALSE;
  6590.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  6591.     return FALSE;
  6592.   if (!m_serviceControl.Decode(strm))
  6593.     return FALSE;
  6594.   if (HasOptionalField(e_endpointIdentifier) && !m_endpointIdentifier.Decode(strm))
  6595.     return FALSE;
  6596.   if (HasOptionalField(e_callSpecific) && !m_callSpecific.Decode(strm))
  6597.     return FALSE;
  6598.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  6599.     return FALSE;
  6600.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  6601.     return FALSE;
  6602.   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
  6603.     return FALSE;
  6604.   if (HasOptionalField(e_featureSet) && !m_featureSet.Decode(strm))
  6605.     return FALSE;
  6606.   if (HasOptionalField(e_genericData) && !m_genericData.Decode(strm))
  6607.     return FALSE;
  6608.  
  6609.   return UnknownExtensionsDecode(strm);
  6610. }
  6611.  
  6612.  
  6613. void H225_ServiceControlIndication::Encode(PASN_Stream & strm) const
  6614. {
  6615.   PreambleEncode(strm);
  6616.  
  6617.   m_requestSeqNum.Encode(strm);
  6618.   if (HasOptionalField(e_nonStandardData))
  6619.     m_nonStandardData.Encode(strm);
  6620.   m_serviceControl.Encode(strm);
  6621.   if (HasOptionalField(e_endpointIdentifier))
  6622.     m_endpointIdentifier.Encode(strm);
  6623.   if (HasOptionalField(e_callSpecific))
  6624.     m_callSpecific.Encode(strm);
  6625.   if (HasOptionalField(e_tokens))
  6626.     m_tokens.Encode(strm);
  6627.   if (HasOptionalField(e_cryptoTokens))
  6628.     m_cryptoTokens.Encode(strm);
  6629.   if (HasOptionalField(e_integrityCheckValue))
  6630.     m_integrityCheckValue.Encode(strm);
  6631.   if (HasOptionalField(e_featureSet))
  6632.     m_featureSet.Encode(strm);
  6633.   if (HasOptionalField(e_genericData))
  6634.     m_genericData.Encode(strm);
  6635.  
  6636.   UnknownExtensionsEncode(strm);
  6637. }
  6638.  
  6639.  
  6640. PObject * H225_ServiceControlIndication::Clone() const
  6641. {
  6642. #ifndef PASN_LEANANDMEAN
  6643.   PAssert(IsClass(H225_ServiceControlIndication::Class()), PInvalidCast);
  6644. #endif
  6645.   return new H225_ServiceControlIndication(*this);
  6646. }
  6647.  
  6648.  
  6649. //
  6650. // ServiceControlResponse
  6651. //
  6652.  
  6653. H225_ServiceControlResponse::H225_ServiceControlResponse(unsigned tag, PASN_Object::TagClass tagClass)
  6654.   : PASN_Sequence(tag, tagClass, 7, TRUE, 0)
  6655. {
  6656. }
  6657.  
  6658.  
  6659. #ifndef PASN_NOPRINTON
  6660. void H225_ServiceControlResponse::PrintOn(ostream & strm) const
  6661. {
  6662.   int indent = strm.precision() + 2;
  6663.   strm << "{\n";
  6664.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  6665.   if (HasOptionalField(e_result))
  6666.     strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  6667.   if (HasOptionalField(e_nonStandardData))
  6668.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  6669.   if (HasOptionalField(e_tokens))
  6670.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  6671.   if (HasOptionalField(e_cryptoTokens))
  6672.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  6673.   if (HasOptionalField(e_integrityCheckValue))
  6674.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  6675.   if (HasOptionalField(e_featureSet))
  6676.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  6677.   if (HasOptionalField(e_genericData))
  6678.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  6679.   strm << setw(indent-1) << "}";
  6680. }
  6681. #endif
  6682.  
  6683.  
  6684. PObject::Comparison H225_ServiceControlResponse::Compare(const PObject & obj) const
  6685. {
  6686. #ifndef PASN_LEANANDMEAN
  6687.   PAssert(IsDescendant(H225_ServiceControlResponse::Class()), PInvalidCast);
  6688. #endif
  6689.   const H225_ServiceControlResponse & other = (const H225_ServiceControlResponse &)obj;
  6690.  
  6691.   Comparison result;
  6692.  
  6693.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  6694.     return result;
  6695.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  6696.     return result;
  6697.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  6698.     return result;
  6699.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  6700.     return result;
  6701.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  6702.     return result;
  6703.   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
  6704.     return result;
  6705.   if ((result = m_featureSet.Compare(other.m_featureSet)) != EqualTo)
  6706.     return result;
  6707.   if ((result = m_genericData.Compare(other.m_genericData)) != EqualTo)
  6708.     return result;
  6709.  
  6710.   return PASN_Sequence::Compare(other);
  6711. }
  6712.  
  6713.  
  6714. PINDEX H225_ServiceControlResponse::GetDataLength() const
  6715. {
  6716.   PINDEX length = 0;
  6717.   length += m_requestSeqNum.GetObjectLength();
  6718.   if (HasOptionalField(e_result))
  6719.     length += m_result.GetObjectLength();
  6720.   if (HasOptionalField(e_nonStandardData))
  6721.     length += m_nonStandardData.GetObjectLength();
  6722.   if (HasOptionalField(e_tokens))
  6723.     length += m_tokens.GetObjectLength();
  6724.   if (HasOptionalField(e_cryptoTokens))
  6725.     length += m_cryptoTokens.GetObjectLength();
  6726.   if (HasOptionalField(e_integrityCheckValue))
  6727.     length += m_integrityCheckValue.GetObjectLength();
  6728.   if (HasOptionalField(e_featureSet))
  6729.     length += m_featureSet.GetObjectLength();
  6730.   if (HasOptionalField(e_genericData))
  6731.     length += m_genericData.GetObjectLength();
  6732.   return length;
  6733. }
  6734.  
  6735.  
  6736. BOOL H225_ServiceControlResponse::Decode(PASN_Stream & strm)
  6737. {
  6738.   if (!PreambleDecode(strm))
  6739.     return FALSE;
  6740.  
  6741.   if (!m_requestSeqNum.Decode(strm))
  6742.     return FALSE;
  6743.   if (HasOptionalField(e_result) && !m_result.Decode(strm))
  6744.     return FALSE;
  6745.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  6746.     return FALSE;
  6747.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  6748.     return FALSE;
  6749.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  6750.     return FALSE;
  6751.   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
  6752.     return FALSE;
  6753.   if (HasOptionalField(e_featureSet) && !m_featureSet.Decode(strm))
  6754.     return FALSE;
  6755.   if (HasOptionalField(e_genericData) && !m_genericData.Decode(strm))
  6756.     return FALSE;
  6757.  
  6758.   return UnknownExtensionsDecode(strm);
  6759. }
  6760.  
  6761.  
  6762. void H225_ServiceControlResponse::Encode(PASN_Stream & strm) const
  6763. {
  6764.   PreambleEncode(strm);
  6765.  
  6766.   m_requestSeqNum.Encode(strm);
  6767.   if (HasOptionalField(e_result))
  6768.     m_result.Encode(strm);
  6769.   if (HasOptionalField(e_nonStandardData))
  6770.     m_nonStandardData.Encode(strm);
  6771.   if (HasOptionalField(e_tokens))
  6772.     m_tokens.Encode(strm);
  6773.   if (HasOptionalField(e_cryptoTokens))
  6774.     m_cryptoTokens.Encode(strm);
  6775.   if (HasOptionalField(e_integrityCheckValue))
  6776.     m_integrityCheckValue.Encode(strm);
  6777.   if (HasOptionalField(e_featureSet))
  6778.     m_featureSet.Encode(strm);
  6779.   if (HasOptionalField(e_genericData))
  6780.     m_genericData.Encode(strm);
  6781.  
  6782.   UnknownExtensionsEncode(strm);
  6783. }
  6784.  
  6785.  
  6786. PObject * H225_ServiceControlResponse::Clone() const
  6787. {
  6788. #ifndef PASN_LEANANDMEAN
  6789.   PAssert(IsClass(H225_ServiceControlResponse::Class()), PInvalidCast);
  6790. #endif
  6791.   return new H225_ServiceControlResponse(*this);
  6792. }
  6793.  
  6794.  
  6795. //
  6796. // H323-UU-PDU_tunnelledSignallingMessage
  6797. //
  6798.  
  6799. H225_H323_UU_PDU_tunnelledSignallingMessage::H225_H323_UU_PDU_tunnelledSignallingMessage(unsigned tag, PASN_Object::TagClass tagClass)
  6800.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  6801. {
  6802. }
  6803.  
  6804.  
  6805. #ifndef PASN_NOPRINTON
  6806. void H225_H323_UU_PDU_tunnelledSignallingMessage::PrintOn(ostream & strm) const
  6807. {
  6808.   int indent = strm.precision() + 2;
  6809.   strm << "{\n";
  6810.   strm << setw(indent+22) << "tunnelledProtocolID = " << setprecision(indent) << m_tunnelledProtocolID << '\n';
  6811.   strm << setw(indent+17) << "messageContent = " << setprecision(indent) << m_messageContent << '\n';
  6812.   if (HasOptionalField(e_tunnellingRequired))
  6813.     strm << setw(indent+21) << "tunnellingRequired = " << setprecision(indent) << m_tunnellingRequired << '\n';
  6814.   if (HasOptionalField(e_nonStandardData))
  6815.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  6816.   strm << setw(indent-1) << "}";
  6817. }
  6818. #endif
  6819.  
  6820.  
  6821. PObject::Comparison H225_H323_UU_PDU_tunnelledSignallingMessage::Compare(const PObject & obj) const
  6822. {
  6823. #ifndef PASN_LEANANDMEAN
  6824.   PAssert(IsDescendant(H225_H323_UU_PDU_tunnelledSignallingMessage::Class()), PInvalidCast);
  6825. #endif
  6826.   const H225_H323_UU_PDU_tunnelledSignallingMessage & other = (const H225_H323_UU_PDU_tunnelledSignallingMessage &)obj;
  6827.  
  6828.   Comparison result;
  6829.  
  6830.   if ((result = m_tunnelledProtocolID.Compare(other.m_tunnelledProtocolID)) != EqualTo)
  6831.     return result;
  6832.   if ((result = m_messageContent.Compare(other.m_messageContent)) != EqualTo)
  6833.     return result;
  6834.   if ((result = m_tunnellingRequired.Compare(other.m_tunnellingRequired)) != EqualTo)
  6835.     return result;
  6836.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  6837.     return result;
  6838.  
  6839.   return PASN_Sequence::Compare(other);
  6840. }
  6841.  
  6842.  
  6843. PINDEX H225_H323_UU_PDU_tunnelledSignallingMessage::GetDataLength() const
  6844. {
  6845.   PINDEX length = 0;
  6846.   length += m_tunnelledProtocolID.GetObjectLength();
  6847.   length += m_messageContent.GetObjectLength();
  6848.   if (HasOptionalField(e_tunnellingRequired))
  6849.     length += m_tunnellingRequired.GetObjectLength();
  6850.   if (HasOptionalField(e_nonStandardData))
  6851.     length += m_nonStandardData.GetObjectLength();
  6852.   return length;
  6853. }
  6854.  
  6855.  
  6856. BOOL H225_H323_UU_PDU_tunnelledSignallingMessage::Decode(PASN_Stream & strm)
  6857. {
  6858.   if (!PreambleDecode(strm))
  6859.     return FALSE;
  6860.  
  6861.   if (!m_tunnelledProtocolID.Decode(strm))
  6862.     return FALSE;
  6863.   if (!m_messageContent.Decode(strm))
  6864.     return FALSE;
  6865.   if (HasOptionalField(e_tunnellingRequired) && !m_tunnellingRequired.Decode(strm))
  6866.     return FALSE;
  6867.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  6868.     return FALSE;
  6869.  
  6870.   return UnknownExtensionsDecode(strm);
  6871. }
  6872.  
  6873.  
  6874. void H225_H323_UU_PDU_tunnelledSignallingMessage::Encode(PASN_Stream & strm) const
  6875. {
  6876.   PreambleEncode(strm);
  6877.  
  6878.   m_tunnelledProtocolID.Encode(strm);
  6879.   m_messageContent.Encode(strm);
  6880.   if (HasOptionalField(e_tunnellingRequired))
  6881.     m_tunnellingRequired.Encode(strm);
  6882.   if (HasOptionalField(e_nonStandardData))
  6883.     m_nonStandardData.Encode(strm);
  6884.  
  6885.   UnknownExtensionsEncode(strm);
  6886. }
  6887.  
  6888.  
  6889. PObject * H225_H323_UU_PDU_tunnelledSignallingMessage::Clone() const
  6890. {
  6891. #ifndef PASN_LEANANDMEAN
  6892.   PAssert(IsClass(H225_H323_UU_PDU_tunnelledSignallingMessage::Class()), PInvalidCast);
  6893. #endif
  6894.   return new H225_H323_UU_PDU_tunnelledSignallingMessage(*this);
  6895. }
  6896.  
  6897.  
  6898. //
  6899. // TransportAddress_ipSourceRoute
  6900. //
  6901.  
  6902. H225_TransportAddress_ipSourceRoute::H225_TransportAddress_ipSourceRoute(unsigned tag, PASN_Object::TagClass tagClass)
  6903.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  6904. {
  6905.   m_ip.SetConstraints(PASN_Object::FixedConstraint, 4);
  6906.   m_port.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  6907. }
  6908.  
  6909.  
  6910. #ifndef PASN_NOPRINTON
  6911. void H225_TransportAddress_ipSourceRoute::PrintOn(ostream & strm) const
  6912. {
  6913.   int indent = strm.precision() + 2;
  6914.   strm << "{\n";
  6915.   strm << setw(indent+5) << "ip = " << setprecision(indent) << m_ip << '\n';
  6916.   strm << setw(indent+7) << "port = " << setprecision(indent) << m_port << '\n';
  6917.   strm << setw(indent+8) << "route = " << setprecision(indent) << m_route << '\n';
  6918.   strm << setw(indent+10) << "routing = " << setprecision(indent) << m_routing << '\n';
  6919.   strm << setw(indent-1) << "}";
  6920. }
  6921. #endif
  6922.  
  6923.  
  6924. PObject::Comparison H225_TransportAddress_ipSourceRoute::Compare(const PObject & obj) const
  6925. {
  6926. #ifndef PASN_LEANANDMEAN
  6927.   PAssert(IsDescendant(H225_TransportAddress_ipSourceRoute::Class()), PInvalidCast);
  6928. #endif
  6929.   const H225_TransportAddress_ipSourceRoute & other = (const H225_TransportAddress_ipSourceRoute &)obj;
  6930.  
  6931.   Comparison result;
  6932.  
  6933.   if ((result = m_ip.Compare(other.m_ip)) != EqualTo)
  6934.     return result;
  6935.   if ((result = m_port.Compare(other.m_port)) != EqualTo)
  6936.     return result;
  6937.   if ((result = m_route.Compare(other.m_route)) != EqualTo)
  6938.     return result;
  6939.   if ((result = m_routing.Compare(other.m_routing)) != EqualTo)
  6940.     return result;
  6941.  
  6942.   return PASN_Sequence::Compare(other);
  6943. }
  6944.  
  6945.  
  6946. PINDEX H225_TransportAddress_ipSourceRoute::GetDataLength() const
  6947. {
  6948.   PINDEX length = 0;
  6949.   length += m_ip.GetObjectLength();
  6950.   length += m_port.GetObjectLength();
  6951.   length += m_route.GetObjectLength();
  6952.   length += m_routing.GetObjectLength();
  6953.   return length;
  6954. }
  6955.  
  6956.  
  6957. BOOL H225_TransportAddress_ipSourceRoute::Decode(PASN_Stream & strm)
  6958. {
  6959.   if (!PreambleDecode(strm))
  6960.     return FALSE;
  6961.  
  6962.   if (!m_ip.Decode(strm))
  6963.     return FALSE;
  6964.   if (!m_port.Decode(strm))
  6965.     return FALSE;
  6966.   if (!m_route.Decode(strm))
  6967.     return FALSE;
  6968.   if (!m_routing.Decode(strm))
  6969.     return FALSE;
  6970.  
  6971.   return UnknownExtensionsDecode(strm);
  6972. }
  6973.  
  6974.  
  6975. void H225_TransportAddress_ipSourceRoute::Encode(PASN_Stream & strm) const
  6976. {
  6977.   PreambleEncode(strm);
  6978.  
  6979.   m_ip.Encode(strm);
  6980.   m_port.Encode(strm);
  6981.   m_route.Encode(strm);
  6982.   m_routing.Encode(strm);
  6983.  
  6984.   UnknownExtensionsEncode(strm);
  6985. }
  6986.  
  6987.  
  6988. PObject * H225_TransportAddress_ipSourceRoute::Clone() const
  6989. {
  6990. #ifndef PASN_LEANANDMEAN
  6991.   PAssert(IsClass(H225_TransportAddress_ipSourceRoute::Class()), PInvalidCast);
  6992. #endif
  6993.   return new H225_TransportAddress_ipSourceRoute(*this);
  6994. }
  6995.  
  6996.  
  6997. //
  6998. // RegistrationConfirm_preGrantedARQ
  6999. //
  7000.  
  7001. H225_RegistrationConfirm_preGrantedARQ::H225_RegistrationConfirm_preGrantedARQ(unsigned tag, PASN_Object::TagClass tagClass)
  7002.   : PASN_Sequence(tag, tagClass, 0, TRUE, 4)
  7003. {
  7004.   m_irrFrequencyInCall.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
  7005. }
  7006.  
  7007.  
  7008. #ifndef PASN_NOPRINTON
  7009. void H225_RegistrationConfirm_preGrantedARQ::PrintOn(ostream & strm) const
  7010. {
  7011.   int indent = strm.precision() + 2;
  7012.   strm << "{\n";
  7013.   strm << setw(indent+11) << "makeCall = " << setprecision(indent) << m_makeCall << '\n';
  7014.   strm << setw(indent+35) << "useGKCallSignalAddressToMakeCall = " << setprecision(indent) << m_useGKCallSignalAddressToMakeCall << '\n';
  7015.   strm << setw(indent+13) << "answerCall = " << setprecision(indent) << m_answerCall << '\n';
  7016.   strm << setw(indent+33) << "useGKCallSignalAddressToAnswer = " << setprecision(indent) << m_useGKCallSignalAddressToAnswer << '\n';
  7017.   if (HasOptionalField(e_irrFrequencyInCall))
  7018.     strm << setw(indent+21) << "irrFrequencyInCall = " << setprecision(indent) << m_irrFrequencyInCall << '\n';
  7019.   if (HasOptionalField(e_totalBandwidthRestriction))
  7020.     strm << setw(indent+28) << "totalBandwidthRestriction = " << setprecision(indent) << m_totalBandwidthRestriction << '\n';
  7021.   if (HasOptionalField(e_alternateTransportAddresses))
  7022.     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
  7023.   if (HasOptionalField(e_useSpecifiedTransport))
  7024.     strm << setw(indent+24) << "useSpecifiedTransport = " << setprecision(indent) << m_useSpecifiedTransport << '\n';
  7025.   strm << setw(indent-1) << "}";
  7026. }
  7027. #endif
  7028.  
  7029.  
  7030. PObject::Comparison H225_RegistrationConfirm_preGrantedARQ::Compare(const PObject & obj) const
  7031. {
  7032. #ifndef PASN_LEANANDMEAN
  7033.   PAssert(IsDescendant(H225_RegistrationConfirm_preGrantedARQ::Class()), PInvalidCast);
  7034. #endif
  7035.   const H225_RegistrationConfirm_preGrantedARQ & other = (const H225_RegistrationConfirm_preGrantedARQ &)obj;
  7036.  
  7037.   Comparison result;
  7038.  
  7039.   if ((result = m_makeCall.Compare(other.m_makeCall)) != EqualTo)
  7040.     return result;
  7041.   if ((result = m_useGKCallSignalAddressToMakeCall.Compare(other.m_useGKCallSignalAddressToMakeCall)) != EqualTo)
  7042.     return result;
  7043.   if ((result = m_answerCall.Compare(other.m_answerCall)) != EqualTo)
  7044.     return result;
  7045.   if ((result = m_useGKCallSignalAddressToAnswer.Compare(other.m_useGKCallSignalAddressToAnswer)) != EqualTo)
  7046.     return result;
  7047.  
  7048.   return PASN_Sequence::Compare(other);
  7049. }
  7050.  
  7051.  
  7052. PINDEX H225_RegistrationConfirm_preGrantedARQ::GetDataLength() const
  7053. {
  7054.   PINDEX length = 0;
  7055.   length += m_makeCall.GetObjectLength();
  7056.   length += m_useGKCallSignalAddressToMakeCall.GetObjectLength();
  7057.   length += m_answerCall.GetObjectLength();
  7058.   length += m_useGKCallSignalAddressToAnswer.GetObjectLength();
  7059.   return length;
  7060. }
  7061.  
  7062.  
  7063. BOOL H225_RegistrationConfirm_preGrantedARQ::Decode(PASN_Stream & strm)
  7064. {
  7065.   if (!PreambleDecode(strm))
  7066.     return FALSE;
  7067.  
  7068.   if (!m_makeCall.Decode(strm))
  7069.     return FALSE;
  7070.   if (!m_useGKCallSignalAddressToMakeCall.Decode(strm))
  7071.     return FALSE;
  7072.   if (!m_answerCall.Decode(strm))
  7073.     return FALSE;
  7074.   if (!m_useGKCallSignalAddressToAnswer.Decode(strm))
  7075.     return FALSE;
  7076.   if (!KnownExtensionDecode(strm, e_irrFrequencyInCall, m_irrFrequencyInCall))
  7077.     return FALSE;
  7078.   if (!KnownExtensionDecode(strm, e_totalBandwidthRestriction, m_totalBandwidthRestriction))
  7079.     return FALSE;
  7080.   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
  7081.     return FALSE;
  7082.   if (!KnownExtensionDecode(strm, e_useSpecifiedTransport, m_useSpecifiedTransport))
  7083.     return FALSE;
  7084.  
  7085.   return UnknownExtensionsDecode(strm);
  7086. }
  7087.  
  7088.  
  7089. void H225_RegistrationConfirm_preGrantedARQ::Encode(PASN_Stream & strm) const
  7090. {
  7091.   PreambleEncode(strm);
  7092.  
  7093.   m_makeCall.Encode(strm);
  7094.   m_useGKCallSignalAddressToMakeCall.Encode(strm);
  7095.   m_answerCall.Encode(strm);
  7096.   m_useGKCallSignalAddressToAnswer.Encode(strm);
  7097.   KnownExtensionEncode(strm, e_irrFrequencyInCall, m_irrFrequencyInCall);
  7098.   KnownExtensionEncode(strm, e_totalBandwidthRestriction, m_totalBandwidthRestriction);
  7099.   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
  7100.   KnownExtensionEncode(strm, e_useSpecifiedTransport, m_useSpecifiedTransport);
  7101.  
  7102.   UnknownExtensionsEncode(strm);
  7103. }
  7104.  
  7105.  
  7106. PObject * H225_RegistrationConfirm_preGrantedARQ::Clone() const
  7107. {
  7108. #ifndef PASN_LEANANDMEAN
  7109.   PAssert(IsClass(H225_RegistrationConfirm_preGrantedARQ::Class()), PInvalidCast);
  7110. #endif
  7111.   return new H225_RegistrationConfirm_preGrantedARQ(*this);
  7112. }
  7113.  
  7114.  
  7115. //
  7116. // InfoRequestResponse_perCallInfo_subtype
  7117. //
  7118.  
  7119. H225_InfoRequestResponse_perCallInfo_subtype::H225_InfoRequestResponse_perCallInfo_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  7120.   : PASN_Sequence(tag, tagClass, 5, TRUE, 8)
  7121. {
  7122.   IncludeOptionalField(e_callIdentifier);
  7123.   IncludeOptionalField(e_substituteConfIDs);
  7124. }
  7125.  
  7126.  
  7127. #ifndef PASN_NOPRINTON
  7128. void H225_InfoRequestResponse_perCallInfo_subtype::PrintOn(ostream & strm) const
  7129. {
  7130.   int indent = strm.precision() + 2;
  7131.   strm << "{\n";
  7132.   if (HasOptionalField(e_nonStandardData))
  7133.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  7134.   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
  7135.   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  7136.   if (HasOptionalField(e_originator))
  7137.     strm << setw(indent+13) << "originator = " << setprecision(indent) << m_originator << '\n';
  7138.   if (HasOptionalField(e_audio))
  7139.     strm << setw(indent+8) << "audio = " << setprecision(indent) << m_audio << '\n';
  7140.   if (HasOptionalField(e_video))
  7141.     strm << setw(indent+8) << "video = " << setprecision(indent) << m_video << '\n';
  7142.   if (HasOptionalField(e_data))
  7143.     strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
  7144.   strm << setw(indent+7) << "h245 = " << setprecision(indent) << m_h245 << '\n';
  7145.   strm << setw(indent+16) << "callSignaling = " << setprecision(indent) << m_callSignaling << '\n';
  7146.   strm << setw(indent+11) << "callType = " << setprecision(indent) << m_callType << '\n';
  7147.   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
  7148.   strm << setw(indent+12) << "callModel = " << setprecision(indent) << m_callModel << '\n';
  7149.   if (HasOptionalField(e_callIdentifier))
  7150.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  7151.   if (HasOptionalField(e_tokens))
  7152.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  7153.   if (HasOptionalField(e_cryptoTokens))
  7154.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  7155.   if (HasOptionalField(e_substituteConfIDs))
  7156.     strm << setw(indent+20) << "substituteConfIDs = " << setprecision(indent) << m_substituteConfIDs << '\n';
  7157.   if (HasOptionalField(e_pdu))
  7158.     strm << setw(indent+6) << "pdu = " << setprecision(indent) << m_pdu << '\n';
  7159.   if (HasOptionalField(e_callLinkage))
  7160.     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
  7161.   if (HasOptionalField(e_usageInformation))
  7162.     strm << setw(indent+19) << "usageInformation = " << setprecision(indent) << m_usageInformation << '\n';
  7163.   if (HasOptionalField(e_circuitInfo))
  7164.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  7165.   strm << setw(indent-1) << "}";
  7166. }
  7167. #endif
  7168.  
  7169.  
  7170. PObject::Comparison H225_InfoRequestResponse_perCallInfo_subtype::Compare(const PObject & obj) const
  7171. {
  7172. #ifndef PASN_LEANANDMEAN
  7173.   PAssert(IsDescendant(H225_InfoRequestResponse_perCallInfo_subtype::Class()), PInvalidCast);
  7174. #endif
  7175.   const H225_InfoRequestResponse_perCallInfo_subtype & other = (const H225_InfoRequestResponse_perCallInfo_subtype &)obj;
  7176.  
  7177.   Comparison result;
  7178.  
  7179.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  7180.     return result;
  7181.   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
  7182.     return result;
  7183.   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
  7184.     return result;
  7185.   if ((result = m_originator.Compare(other.m_originator)) != EqualTo)
  7186.     return result;
  7187.   if ((result = m_audio.Compare(other.m_audio)) != EqualTo)
  7188.     return result;
  7189.   if ((result = m_video.Compare(other.m_video)) != EqualTo)
  7190.     return result;
  7191.   if ((result = m_data.Compare(other.m_data)) != EqualTo)
  7192.     return result;
  7193.   if ((result = m_h245.Compare(other.m_h245)) != EqualTo)
  7194.     return result;
  7195.   if ((result = m_callSignaling.Compare(other.m_callSignaling)) != EqualTo)
  7196.     return result;
  7197.   if ((result = m_callType.Compare(other.m_callType)) != EqualTo)
  7198.     return result;
  7199.   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
  7200.     return result;
  7201.   if ((result = m_callModel.Compare(other.m_callModel)) != EqualTo)
  7202.     return result;
  7203.  
  7204.   return PASN_Sequence::Compare(other);
  7205. }
  7206.  
  7207.  
  7208. PINDEX H225_InfoRequestResponse_perCallInfo_subtype::GetDataLength() const
  7209. {
  7210.   PINDEX length = 0;
  7211.   if (HasOptionalField(e_nonStandardData))
  7212.     length += m_nonStandardData.GetObjectLength();
  7213.   length += m_callReferenceValue.GetObjectLength();
  7214.   length += m_conferenceID.GetObjectLength();
  7215.   if (HasOptionalField(e_originator))
  7216.     length += m_originator.GetObjectLength();
  7217.   if (HasOptionalField(e_audio))
  7218.     length += m_audio.GetObjectLength();
  7219.   if (HasOptionalField(e_video))
  7220.     length += m_video.GetObjectLength();
  7221.   if (HasOptionalField(e_data))
  7222.     length += m_data.GetObjectLength();
  7223.   length += m_h245.GetObjectLength();
  7224.   length += m_callSignaling.GetObjectLength();
  7225.   length += m_callType.GetObjectLength();
  7226.   length += m_bandWidth.GetObjectLength();
  7227.   length += m_callModel.GetObjectLength();
  7228.   return length;
  7229. }
  7230.  
  7231.  
  7232. BOOL H225_InfoRequestResponse_perCallInfo_subtype::Decode(PASN_Stream & strm)
  7233. {
  7234.   if (!PreambleDecode(strm))
  7235.     return FALSE;
  7236.  
  7237.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  7238.     return FALSE;
  7239.   if (!m_callReferenceValue.Decode(strm))
  7240.     return FALSE;
  7241.   if (!m_conferenceID.Decode(strm))
  7242.     return FALSE;
  7243.   if (HasOptionalField(e_originator) && !m_originator.Decode(strm))
  7244.     return FALSE;
  7245.   if (HasOptionalField(e_audio) && !m_audio.Decode(strm))
  7246.     return FALSE;
  7247.   if (HasOptionalField(e_video) && !m_video.Decode(strm))
  7248.     return FALSE;
  7249.   if (HasOptionalField(e_data) && !m_data.Decode(strm))
  7250.     return FALSE;
  7251.   if (!m_h245.Decode(strm))
  7252.     return FALSE;
  7253.   if (!m_callSignaling.Decode(strm))
  7254.     return FALSE;
  7255.   if (!m_callType.Decode(strm))
  7256.     return FALSE;
  7257.   if (!m_bandWidth.Decode(strm))
  7258.     return FALSE;
  7259.   if (!m_callModel.Decode(strm))
  7260.     return FALSE;
  7261.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  7262.     return FALSE;
  7263.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  7264.     return FALSE;
  7265.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  7266.     return FALSE;
  7267.   if (!KnownExtensionDecode(strm, e_substituteConfIDs, m_substituteConfIDs))
  7268.     return FALSE;
  7269.   if (!KnownExtensionDecode(strm, e_pdu, m_pdu))
  7270.     return FALSE;
  7271.   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
  7272.     return FALSE;
  7273.   if (!KnownExtensionDecode(strm, e_usageInformation, m_usageInformation))
  7274.     return FALSE;
  7275.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  7276.     return FALSE;
  7277.  
  7278.   return UnknownExtensionsDecode(strm);
  7279. }
  7280.  
  7281.  
  7282. void H225_InfoRequestResponse_perCallInfo_subtype::Encode(PASN_Stream & strm) const
  7283. {
  7284.   PreambleEncode(strm);
  7285.  
  7286.   if (HasOptionalField(e_nonStandardData))
  7287.     m_nonStandardData.Encode(strm);
  7288.   m_callReferenceValue.Encode(strm);
  7289.   m_conferenceID.Encode(strm);
  7290.   if (HasOptionalField(e_originator))
  7291.     m_originator.Encode(strm);
  7292.   if (HasOptionalField(e_audio))
  7293.     m_audio.Encode(strm);
  7294.   if (HasOptionalField(e_video))
  7295.     m_video.Encode(strm);
  7296.   if (HasOptionalField(e_data))
  7297.     m_data.Encode(strm);
  7298.   m_h245.Encode(strm);
  7299.   m_callSignaling.Encode(strm);
  7300.   m_callType.Encode(strm);
  7301.   m_bandWidth.Encode(strm);
  7302.   m_callModel.Encode(strm);
  7303.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  7304.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  7305.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  7306.   KnownExtensionEncode(strm, e_substituteConfIDs, m_substituteConfIDs);
  7307.   KnownExtensionEncode(strm, e_pdu, m_pdu);
  7308.   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
  7309.   KnownExtensionEncode(strm, e_usageInformation, m_usageInformation);
  7310.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  7311.  
  7312.   UnknownExtensionsEncode(strm);
  7313. }
  7314.  
  7315.  
  7316. PObject * H225_InfoRequestResponse_perCallInfo_subtype::Clone() const
  7317. {
  7318. #ifndef PASN_LEANANDMEAN
  7319.   PAssert(IsClass(H225_InfoRequestResponse_perCallInfo_subtype::Class()), PInvalidCast);
  7320. #endif
  7321.   return new H225_InfoRequestResponse_perCallInfo_subtype(*this);
  7322. }
  7323.  
  7324.  
  7325. //
  7326. // StimulusControl
  7327. //
  7328.  
  7329. H225_StimulusControl::H225_StimulusControl(unsigned tag, PASN_Object::TagClass tagClass)
  7330.   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
  7331. {
  7332. }
  7333.  
  7334.  
  7335. #ifndef PASN_NOPRINTON
  7336. void H225_StimulusControl::PrintOn(ostream & strm) const
  7337. {
  7338.   int indent = strm.precision() + 2;
  7339.   strm << "{\n";
  7340.   if (HasOptionalField(e_nonStandard))
  7341.     strm << setw(indent+14) << "nonStandard = " << setprecision(indent) << m_nonStandard << '\n';
  7342.   if (HasOptionalField(e_isText))
  7343.     strm << setw(indent+9) << "isText = " << setprecision(indent) << m_isText << '\n';
  7344.   if (HasOptionalField(e_h248Message))
  7345.     strm << setw(indent+14) << "h248Message = " << setprecision(indent) << m_h248Message << '\n';
  7346.   strm << setw(indent-1) << "}";
  7347. }
  7348. #endif
  7349.  
  7350.  
  7351. PObject::Comparison H225_StimulusControl::Compare(const PObject & obj) const
  7352. {
  7353. #ifndef PASN_LEANANDMEAN
  7354.   PAssert(IsDescendant(H225_StimulusControl::Class()), PInvalidCast);
  7355. #endif
  7356.   const H225_StimulusControl & other = (const H225_StimulusControl &)obj;
  7357.  
  7358.   Comparison result;
  7359.  
  7360.   if ((result = m_nonStandard.Compare(other.m_nonStandard)) != EqualTo)
  7361.     return result;
  7362.   if ((result = m_isText.Compare(other.m_isText)) != EqualTo)
  7363.     return result;
  7364.   if ((result = m_h248Message.Compare(other.m_h248Message)) != EqualTo)
  7365.     return result;
  7366.  
  7367.   return PASN_Sequence::Compare(other);
  7368. }
  7369.  
  7370.  
  7371. PINDEX H225_StimulusControl::GetDataLength() const
  7372. {
  7373.   PINDEX length = 0;
  7374.   if (HasOptionalField(e_nonStandard))
  7375.     length += m_nonStandard.GetObjectLength();
  7376.   if (HasOptionalField(e_isText))
  7377.     length += m_isText.GetObjectLength();
  7378.   if (HasOptionalField(e_h248Message))
  7379.     length += m_h248Message.GetObjectLength();
  7380.   return length;
  7381. }
  7382.  
  7383.  
  7384. BOOL H225_StimulusControl::Decode(PASN_Stream & strm)
  7385. {
  7386.   if (!PreambleDecode(strm))
  7387.     return FALSE;
  7388.  
  7389.   if (HasOptionalField(e_nonStandard) && !m_nonStandard.Decode(strm))
  7390.     return FALSE;
  7391.   if (HasOptionalField(e_isText) && !m_isText.Decode(strm))
  7392.     return FALSE;
  7393.   if (HasOptionalField(e_h248Message) && !m_h248Message.Decode(strm))
  7394.     return FALSE;
  7395.  
  7396.   return UnknownExtensionsDecode(strm);
  7397. }
  7398.  
  7399.  
  7400. void H225_StimulusControl::Encode(PASN_Stream & strm) const
  7401. {
  7402.   PreambleEncode(strm);
  7403.  
  7404.   if (HasOptionalField(e_nonStandard))
  7405.     m_nonStandard.Encode(strm);
  7406.   if (HasOptionalField(e_isText))
  7407.     m_isText.Encode(strm);
  7408.   if (HasOptionalField(e_h248Message))
  7409.     m_h248Message.Encode(strm);
  7410.  
  7411.   UnknownExtensionsEncode(strm);
  7412. }
  7413.  
  7414.  
  7415. PObject * H225_StimulusControl::Clone() const
  7416. {
  7417. #ifndef PASN_LEANANDMEAN
  7418.   PAssert(IsClass(H225_StimulusControl::Class()), PInvalidCast);
  7419. #endif
  7420.   return new H225_StimulusControl(*this);
  7421. }
  7422.  
  7423.  
  7424. //
  7425. // Information-UUIE
  7426. //
  7427.  
  7428. H225_Information_UUIE::H225_Information_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  7429.   : PASN_Sequence(tag, tagClass, 0, TRUE, 6)
  7430. {
  7431.   IncludeOptionalField(e_callIdentifier);
  7432. }
  7433.  
  7434.  
  7435. #ifndef PASN_NOPRINTON
  7436. void H225_Information_UUIE::PrintOn(ostream & strm) const
  7437. {
  7438.   int indent = strm.precision() + 2;
  7439.   strm << "{\n";
  7440.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  7441.   if (HasOptionalField(e_callIdentifier))
  7442.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  7443.   if (HasOptionalField(e_tokens))
  7444.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  7445.   if (HasOptionalField(e_cryptoTokens))
  7446.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  7447.   if (HasOptionalField(e_fastStart))
  7448.     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
  7449.   if (HasOptionalField(e_fastConnectRefused))
  7450.     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
  7451.   if (HasOptionalField(e_circuitInfo))
  7452.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  7453.   strm << setw(indent-1) << "}";
  7454. }
  7455. #endif
  7456.  
  7457.  
  7458. PObject::Comparison H225_Information_UUIE::Compare(const PObject & obj) const
  7459. {
  7460. #ifndef PASN_LEANANDMEAN
  7461.   PAssert(IsDescendant(H225_Information_UUIE::Class()), PInvalidCast);
  7462. #endif
  7463.   const H225_Information_UUIE & other = (const H225_Information_UUIE &)obj;
  7464.  
  7465.   Comparison result;
  7466.  
  7467.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  7468.     return result;
  7469.  
  7470.   return PASN_Sequence::Compare(other);
  7471. }
  7472.  
  7473.  
  7474. PINDEX H225_Information_UUIE::GetDataLength() const
  7475. {
  7476.   PINDEX length = 0;
  7477.   length += m_protocolIdentifier.GetObjectLength();
  7478.   return length;
  7479. }
  7480.  
  7481.  
  7482. BOOL H225_Information_UUIE::Decode(PASN_Stream & strm)
  7483. {
  7484.   if (!PreambleDecode(strm))
  7485.     return FALSE;
  7486.  
  7487.   if (!m_protocolIdentifier.Decode(strm))
  7488.     return FALSE;
  7489.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  7490.     return FALSE;
  7491.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  7492.     return FALSE;
  7493.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  7494.     return FALSE;
  7495.   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
  7496.     return FALSE;
  7497.   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
  7498.     return FALSE;
  7499.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  7500.     return FALSE;
  7501.  
  7502.   return UnknownExtensionsDecode(strm);
  7503. }
  7504.  
  7505.  
  7506. void H225_Information_UUIE::Encode(PASN_Stream & strm) const
  7507. {
  7508.   PreambleEncode(strm);
  7509.  
  7510.   m_protocolIdentifier.Encode(strm);
  7511.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  7512.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  7513.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  7514.   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
  7515.   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
  7516.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  7517.  
  7518.   UnknownExtensionsEncode(strm);
  7519. }
  7520.  
  7521.  
  7522. PObject * H225_Information_UUIE::Clone() const
  7523. {
  7524. #ifndef PASN_LEANANDMEAN
  7525.   PAssert(IsClass(H225_Information_UUIE::Class()), PInvalidCast);
  7526. #endif
  7527.   return new H225_Information_UUIE(*this);
  7528. }
  7529.  
  7530.  
  7531. //
  7532. // ConferenceList
  7533. //
  7534.  
  7535. H225_ConferenceList::H225_ConferenceList(unsigned tag, PASN_Object::TagClass tagClass)
  7536.   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
  7537. {
  7538. }
  7539.  
  7540.  
  7541. #ifndef PASN_NOPRINTON
  7542. void H225_ConferenceList::PrintOn(ostream & strm) const
  7543. {
  7544.   int indent = strm.precision() + 2;
  7545.   strm << "{\n";
  7546.   if (HasOptionalField(e_conferenceID))
  7547.     strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  7548.   if (HasOptionalField(e_conferenceAlias))
  7549.     strm << setw(indent+18) << "conferenceAlias = " << setprecision(indent) << m_conferenceAlias << '\n';
  7550.   if (HasOptionalField(e_nonStandardData))
  7551.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  7552.   strm << setw(indent-1) << "}";
  7553. }
  7554. #endif
  7555.  
  7556.  
  7557. PObject::Comparison H225_ConferenceList::Compare(const PObject & obj) const
  7558. {
  7559. #ifndef PASN_LEANANDMEAN
  7560.   PAssert(IsDescendant(H225_ConferenceList::Class()), PInvalidCast);
  7561. #endif
  7562.   const H225_ConferenceList & other = (const H225_ConferenceList &)obj;
  7563.  
  7564.   Comparison result;
  7565.  
  7566.   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
  7567.     return result;
  7568.   if ((result = m_conferenceAlias.Compare(other.m_conferenceAlias)) != EqualTo)
  7569.     return result;
  7570.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  7571.     return result;
  7572.  
  7573.   return PASN_Sequence::Compare(other);
  7574. }
  7575.  
  7576.  
  7577. PINDEX H225_ConferenceList::GetDataLength() const
  7578. {
  7579.   PINDEX length = 0;
  7580.   if (HasOptionalField(e_conferenceID))
  7581.     length += m_conferenceID.GetObjectLength();
  7582.   if (HasOptionalField(e_conferenceAlias))
  7583.     length += m_conferenceAlias.GetObjectLength();
  7584.   if (HasOptionalField(e_nonStandardData))
  7585.     length += m_nonStandardData.GetObjectLength();
  7586.   return length;
  7587. }
  7588.  
  7589.  
  7590. BOOL H225_ConferenceList::Decode(PASN_Stream & strm)
  7591. {
  7592.   if (!PreambleDecode(strm))
  7593.     return FALSE;
  7594.  
  7595.   if (HasOptionalField(e_conferenceID) && !m_conferenceID.Decode(strm))
  7596.     return FALSE;
  7597.   if (HasOptionalField(e_conferenceAlias) && !m_conferenceAlias.Decode(strm))
  7598.     return FALSE;
  7599.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  7600.     return FALSE;
  7601.  
  7602.   return UnknownExtensionsDecode(strm);
  7603. }
  7604.  
  7605.  
  7606. void H225_ConferenceList::Encode(PASN_Stream & strm) const
  7607. {
  7608.   PreambleEncode(strm);
  7609.  
  7610.   if (HasOptionalField(e_conferenceID))
  7611.     m_conferenceID.Encode(strm);
  7612.   if (HasOptionalField(e_conferenceAlias))
  7613.     m_conferenceAlias.Encode(strm);
  7614.   if (HasOptionalField(e_nonStandardData))
  7615.     m_nonStandardData.Encode(strm);
  7616.  
  7617.   UnknownExtensionsEncode(strm);
  7618. }
  7619.  
  7620.  
  7621. PObject * H225_ConferenceList::Clone() const
  7622. {
  7623. #ifndef PASN_LEANANDMEAN
  7624.   PAssert(IsClass(H225_ConferenceList::Class()), PInvalidCast);
  7625. #endif
  7626.   return new H225_ConferenceList(*this);
  7627. }
  7628.  
  7629.  
  7630. //
  7631. // GatewayInfo
  7632. //
  7633.  
  7634. H225_GatewayInfo::H225_GatewayInfo(unsigned tag, PASN_Object::TagClass tagClass)
  7635.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  7636. {
  7637. }
  7638.  
  7639.  
  7640. #ifndef PASN_NOPRINTON
  7641. void H225_GatewayInfo::PrintOn(ostream & strm) const
  7642. {
  7643.   int indent = strm.precision() + 2;
  7644.   strm << "{\n";
  7645.   if (HasOptionalField(e_protocol))
  7646.     strm << setw(indent+11) << "protocol = " << setprecision(indent) << m_protocol << '\n';
  7647.   if (HasOptionalField(e_nonStandardData))
  7648.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  7649.   strm << setw(indent-1) << "}";
  7650. }
  7651. #endif
  7652.  
  7653.  
  7654. PObject::Comparison H225_GatewayInfo::Compare(const PObject & obj) const
  7655. {
  7656. #ifndef PASN_LEANANDMEAN
  7657.   PAssert(IsDescendant(H225_GatewayInfo::Class()), PInvalidCast);
  7658. #endif
  7659.   const H225_GatewayInfo & other = (const H225_GatewayInfo &)obj;
  7660.  
  7661.   Comparison result;
  7662.  
  7663.   if ((result = m_protocol.Compare(other.m_protocol)) != EqualTo)
  7664.     return result;
  7665.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  7666.     return result;
  7667.  
  7668.   return PASN_Sequence::Compare(other);
  7669. }
  7670.  
  7671.  
  7672. PINDEX H225_GatewayInfo::GetDataLength() const
  7673. {
  7674.   PINDEX length = 0;
  7675.   if (HasOptionalField(e_protocol))
  7676.     length += m_protocol.GetObjectLength();
  7677.   if (HasOptionalField(e_nonStandardData))
  7678.     length += m_nonStandardData.GetObjectLength();
  7679.   return length;
  7680. }
  7681.  
  7682.  
  7683. BOOL H225_GatewayInfo::Decode(PASN_Stream & strm)
  7684. {
  7685.   if (!PreambleDecode(strm))
  7686.     return FALSE;
  7687.  
  7688.   if (HasOptionalField(e_protocol) && !m_protocol.Decode(strm))
  7689.     return FALSE;
  7690.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  7691.     return FALSE;
  7692.  
  7693.   return UnknownExtensionsDecode(strm);
  7694. }
  7695.  
  7696.  
  7697. void H225_GatewayInfo::Encode(PASN_Stream & strm) const
  7698. {
  7699.   PreambleEncode(strm);
  7700.  
  7701.   if (HasOptionalField(e_protocol))
  7702.     m_protocol.Encode(strm);
  7703.   if (HasOptionalField(e_nonStandardData))
  7704.     m_nonStandardData.Encode(strm);
  7705.  
  7706.   UnknownExtensionsEncode(strm);
  7707. }
  7708.  
  7709.  
  7710. PObject * H225_GatewayInfo::Clone() const
  7711. {
  7712. #ifndef PASN_LEANANDMEAN
  7713.   PAssert(IsClass(H225_GatewayInfo::Class()), PInvalidCast);
  7714. #endif
  7715.   return new H225_GatewayInfo(*this);
  7716. }
  7717.  
  7718.  
  7719. //
  7720. // H310Caps
  7721. //
  7722.  
  7723. H225_H310Caps::H225_H310Caps(unsigned tag, PASN_Object::TagClass tagClass)
  7724.   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
  7725. {
  7726.   IncludeOptionalField(e_supportedPrefixes);
  7727. }
  7728.  
  7729.  
  7730. #ifndef PASN_NOPRINTON
  7731. void H225_H310Caps::PrintOn(ostream & strm) const
  7732. {
  7733.   int indent = strm.precision() + 2;
  7734.   strm << "{\n";
  7735.   if (HasOptionalField(e_nonStandardData))
  7736.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  7737.   if (HasOptionalField(e_dataRatesSupported))
  7738.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  7739.   if (HasOptionalField(e_supportedPrefixes))
  7740.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  7741.   strm << setw(indent-1) << "}";
  7742. }
  7743. #endif
  7744.  
  7745.  
  7746. PObject::Comparison H225_H310Caps::Compare(const PObject & obj) const
  7747. {
  7748. #ifndef PASN_LEANANDMEAN
  7749.   PAssert(IsDescendant(H225_H310Caps::Class()), PInvalidCast);
  7750. #endif
  7751.   const H225_H310Caps & other = (const H225_H310Caps &)obj;
  7752.  
  7753.   Comparison result;
  7754.  
  7755.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  7756.     return result;
  7757.  
  7758.   return PASN_Sequence::Compare(other);
  7759. }
  7760.  
  7761.  
  7762. PINDEX H225_H310Caps::GetDataLength() const
  7763. {
  7764.   PINDEX length = 0;
  7765.   if (HasOptionalField(e_nonStandardData))
  7766.     length += m_nonStandardData.GetObjectLength();
  7767.   return length;
  7768. }
  7769.  
  7770.  
  7771. BOOL H225_H310Caps::Decode(PASN_Stream & strm)
  7772. {
  7773.   if (!PreambleDecode(strm))
  7774.     return FALSE;
  7775.  
  7776.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  7777.     return FALSE;
  7778.   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
  7779.     return FALSE;
  7780.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  7781.     return FALSE;
  7782.  
  7783.   return UnknownExtensionsDecode(strm);
  7784. }
  7785.  
  7786.  
  7787. void H225_H310Caps::Encode(PASN_Stream & strm) const
  7788. {
  7789.   PreambleEncode(strm);
  7790.  
  7791.   if (HasOptionalField(e_nonStandardData))
  7792.     m_nonStandardData.Encode(strm);
  7793.   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
  7794.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  7795.  
  7796.   UnknownExtensionsEncode(strm);
  7797. }
  7798.  
  7799.  
  7800. PObject * H225_H310Caps::Clone() const
  7801. {
  7802. #ifndef PASN_LEANANDMEAN
  7803.   PAssert(IsClass(H225_H310Caps::Class()), PInvalidCast);
  7804. #endif
  7805.   return new H225_H310Caps(*this);
  7806. }
  7807.  
  7808.  
  7809. //
  7810. // H320Caps
  7811. //
  7812.  
  7813. H225_H320Caps::H225_H320Caps(unsigned tag, PASN_Object::TagClass tagClass)
  7814.   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
  7815. {
  7816.   IncludeOptionalField(e_supportedPrefixes);
  7817. }
  7818.  
  7819.  
  7820. #ifndef PASN_NOPRINTON
  7821. void H225_H320Caps::PrintOn(ostream & strm) const
  7822. {
  7823.   int indent = strm.precision() + 2;
  7824.   strm << "{\n";
  7825.   if (HasOptionalField(e_nonStandardData))
  7826.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  7827.   if (HasOptionalField(e_dataRatesSupported))
  7828.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  7829.   if (HasOptionalField(e_supportedPrefixes))
  7830.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  7831.   strm << setw(indent-1) << "}";
  7832. }
  7833. #endif
  7834.  
  7835.  
  7836. PObject::Comparison H225_H320Caps::Compare(const PObject & obj) const
  7837. {
  7838. #ifndef PASN_LEANANDMEAN
  7839.   PAssert(IsDescendant(H225_H320Caps::Class()), PInvalidCast);
  7840. #endif
  7841.   const H225_H320Caps & other = (const H225_H320Caps &)obj;
  7842.  
  7843.   Comparison result;
  7844.  
  7845.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  7846.     return result;
  7847.  
  7848.   return PASN_Sequence::Compare(other);
  7849. }
  7850.  
  7851.  
  7852. PINDEX H225_H320Caps::GetDataLength() const
  7853. {
  7854.   PINDEX length = 0;
  7855.   if (HasOptionalField(e_nonStandardData))
  7856.     length += m_nonStandardData.GetObjectLength();
  7857.   return length;
  7858. }
  7859.  
  7860.  
  7861. BOOL H225_H320Caps::Decode(PASN_Stream & strm)
  7862. {
  7863.   if (!PreambleDecode(strm))
  7864.     return FALSE;
  7865.  
  7866.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  7867.     return FALSE;
  7868.   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
  7869.     return FALSE;
  7870.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  7871.     return FALSE;
  7872.  
  7873.   return UnknownExtensionsDecode(strm);
  7874. }
  7875.  
  7876.  
  7877. void H225_H320Caps::Encode(PASN_Stream & strm) const
  7878. {
  7879.   PreambleEncode(strm);
  7880.  
  7881.   if (HasOptionalField(e_nonStandardData))
  7882.     m_nonStandardData.Encode(strm);
  7883.   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
  7884.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  7885.  
  7886.   UnknownExtensionsEncode(strm);
  7887. }
  7888.  
  7889.  
  7890. PObject * H225_H320Caps::Clone() const
  7891. {
  7892. #ifndef PASN_LEANANDMEAN
  7893.   PAssert(IsClass(H225_H320Caps::Class()), PInvalidCast);
  7894. #endif
  7895.   return new H225_H320Caps(*this);
  7896. }
  7897.  
  7898.  
  7899. //
  7900. // H321Caps
  7901. //
  7902.  
  7903. H225_H321Caps::H225_H321Caps(unsigned tag, PASN_Object::TagClass tagClass)
  7904.   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
  7905. {
  7906.   IncludeOptionalField(e_supportedPrefixes);
  7907. }
  7908.  
  7909.  
  7910. #ifndef PASN_NOPRINTON
  7911. void H225_H321Caps::PrintOn(ostream & strm) const
  7912. {
  7913.   int indent = strm.precision() + 2;
  7914.   strm << "{\n";
  7915.   if (HasOptionalField(e_nonStandardData))
  7916.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  7917.   if (HasOptionalField(e_dataRatesSupported))
  7918.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  7919.   if (HasOptionalField(e_supportedPrefixes))
  7920.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  7921.   strm << setw(indent-1) << "}";
  7922. }
  7923. #endif
  7924.  
  7925.  
  7926. PObject::Comparison H225_H321Caps::Compare(const PObject & obj) const
  7927. {
  7928. #ifndef PASN_LEANANDMEAN
  7929.   PAssert(IsDescendant(H225_H321Caps::Class()), PInvalidCast);
  7930. #endif
  7931.   const H225_H321Caps & other = (const H225_H321Caps &)obj;
  7932.  
  7933.   Comparison result;
  7934.  
  7935.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  7936.     return result;
  7937.  
  7938.   return PASN_Sequence::Compare(other);
  7939. }
  7940.  
  7941.  
  7942. PINDEX H225_H321Caps::GetDataLength() const
  7943. {
  7944.   PINDEX length = 0;
  7945.   if (HasOptionalField(e_nonStandardData))
  7946.     length += m_nonStandardData.GetObjectLength();
  7947.   return length;
  7948. }
  7949.  
  7950.  
  7951. BOOL H225_H321Caps::Decode(PASN_Stream & strm)
  7952. {
  7953.   if (!PreambleDecode(strm))
  7954.     return FALSE;
  7955.  
  7956.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  7957.     return FALSE;
  7958.   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
  7959.     return FALSE;
  7960.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  7961.     return FALSE;
  7962.  
  7963.   return UnknownExtensionsDecode(strm);
  7964. }
  7965.  
  7966.  
  7967. void H225_H321Caps::Encode(PASN_Stream & strm) const
  7968. {
  7969.   PreambleEncode(strm);
  7970.  
  7971.   if (HasOptionalField(e_nonStandardData))
  7972.     m_nonStandardData.Encode(strm);
  7973.   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
  7974.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  7975.  
  7976.   UnknownExtensionsEncode(strm);
  7977. }
  7978.  
  7979.  
  7980. PObject * H225_H321Caps::Clone() const
  7981. {
  7982. #ifndef PASN_LEANANDMEAN
  7983.   PAssert(IsClass(H225_H321Caps::Class()), PInvalidCast);
  7984. #endif
  7985.   return new H225_H321Caps(*this);
  7986. }
  7987.  
  7988.  
  7989. //
  7990. // H322Caps
  7991. //
  7992.  
  7993. H225_H322Caps::H225_H322Caps(unsigned tag, PASN_Object::TagClass tagClass)
  7994.   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
  7995. {
  7996.   IncludeOptionalField(e_supportedPrefixes);
  7997. }
  7998.  
  7999.  
  8000. #ifndef PASN_NOPRINTON
  8001. void H225_H322Caps::PrintOn(ostream & strm) const
  8002. {
  8003.   int indent = strm.precision() + 2;
  8004.   strm << "{\n";
  8005.   if (HasOptionalField(e_nonStandardData))
  8006.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8007.   if (HasOptionalField(e_dataRatesSupported))
  8008.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  8009.   if (HasOptionalField(e_supportedPrefixes))
  8010.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  8011.   strm << setw(indent-1) << "}";
  8012. }
  8013. #endif
  8014.  
  8015.  
  8016. PObject::Comparison H225_H322Caps::Compare(const PObject & obj) const
  8017. {
  8018. #ifndef PASN_LEANANDMEAN
  8019.   PAssert(IsDescendant(H225_H322Caps::Class()), PInvalidCast);
  8020. #endif
  8021.   const H225_H322Caps & other = (const H225_H322Caps &)obj;
  8022.  
  8023.   Comparison result;
  8024.  
  8025.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8026.     return result;
  8027.  
  8028.   return PASN_Sequence::Compare(other);
  8029. }
  8030.  
  8031.  
  8032. PINDEX H225_H322Caps::GetDataLength() const
  8033. {
  8034.   PINDEX length = 0;
  8035.   if (HasOptionalField(e_nonStandardData))
  8036.     length += m_nonStandardData.GetObjectLength();
  8037.   return length;
  8038. }
  8039.  
  8040.  
  8041. BOOL H225_H322Caps::Decode(PASN_Stream & strm)
  8042. {
  8043.   if (!PreambleDecode(strm))
  8044.     return FALSE;
  8045.  
  8046.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8047.     return FALSE;
  8048.   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
  8049.     return FALSE;
  8050.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  8051.     return FALSE;
  8052.  
  8053.   return UnknownExtensionsDecode(strm);
  8054. }
  8055.  
  8056.  
  8057. void H225_H322Caps::Encode(PASN_Stream & strm) const
  8058. {
  8059.   PreambleEncode(strm);
  8060.  
  8061.   if (HasOptionalField(e_nonStandardData))
  8062.     m_nonStandardData.Encode(strm);
  8063.   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
  8064.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  8065.  
  8066.   UnknownExtensionsEncode(strm);
  8067. }
  8068.  
  8069.  
  8070. PObject * H225_H322Caps::Clone() const
  8071. {
  8072. #ifndef PASN_LEANANDMEAN
  8073.   PAssert(IsClass(H225_H322Caps::Class()), PInvalidCast);
  8074. #endif
  8075.   return new H225_H322Caps(*this);
  8076. }
  8077.  
  8078.  
  8079. //
  8080. // H323Caps
  8081. //
  8082.  
  8083. H225_H323Caps::H225_H323Caps(unsigned tag, PASN_Object::TagClass tagClass)
  8084.   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
  8085. {
  8086.   IncludeOptionalField(e_supportedPrefixes);
  8087. }
  8088.  
  8089.  
  8090. #ifndef PASN_NOPRINTON
  8091. void H225_H323Caps::PrintOn(ostream & strm) const
  8092. {
  8093.   int indent = strm.precision() + 2;
  8094.   strm << "{\n";
  8095.   if (HasOptionalField(e_nonStandardData))
  8096.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8097.   if (HasOptionalField(e_dataRatesSupported))
  8098.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  8099.   if (HasOptionalField(e_supportedPrefixes))
  8100.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  8101.   strm << setw(indent-1) << "}";
  8102. }
  8103. #endif
  8104.  
  8105.  
  8106. PObject::Comparison H225_H323Caps::Compare(const PObject & obj) const
  8107. {
  8108. #ifndef PASN_LEANANDMEAN
  8109.   PAssert(IsDescendant(H225_H323Caps::Class()), PInvalidCast);
  8110. #endif
  8111.   const H225_H323Caps & other = (const H225_H323Caps &)obj;
  8112.  
  8113.   Comparison result;
  8114.  
  8115.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8116.     return result;
  8117.  
  8118.   return PASN_Sequence::Compare(other);
  8119. }
  8120.  
  8121.  
  8122. PINDEX H225_H323Caps::GetDataLength() const
  8123. {
  8124.   PINDEX length = 0;
  8125.   if (HasOptionalField(e_nonStandardData))
  8126.     length += m_nonStandardData.GetObjectLength();
  8127.   return length;
  8128. }
  8129.  
  8130.  
  8131. BOOL H225_H323Caps::Decode(PASN_Stream & strm)
  8132. {
  8133.   if (!PreambleDecode(strm))
  8134.     return FALSE;
  8135.  
  8136.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8137.     return FALSE;
  8138.   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
  8139.     return FALSE;
  8140.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  8141.     return FALSE;
  8142.  
  8143.   return UnknownExtensionsDecode(strm);
  8144. }
  8145.  
  8146.  
  8147. void H225_H323Caps::Encode(PASN_Stream & strm) const
  8148. {
  8149.   PreambleEncode(strm);
  8150.  
  8151.   if (HasOptionalField(e_nonStandardData))
  8152.     m_nonStandardData.Encode(strm);
  8153.   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
  8154.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  8155.  
  8156.   UnknownExtensionsEncode(strm);
  8157. }
  8158.  
  8159.  
  8160. PObject * H225_H323Caps::Clone() const
  8161. {
  8162. #ifndef PASN_LEANANDMEAN
  8163.   PAssert(IsClass(H225_H323Caps::Class()), PInvalidCast);
  8164. #endif
  8165.   return new H225_H323Caps(*this);
  8166. }
  8167.  
  8168.  
  8169. //
  8170. // H324Caps
  8171. //
  8172.  
  8173. H225_H324Caps::H225_H324Caps(unsigned tag, PASN_Object::TagClass tagClass)
  8174.   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
  8175. {
  8176.   IncludeOptionalField(e_supportedPrefixes);
  8177. }
  8178.  
  8179.  
  8180. #ifndef PASN_NOPRINTON
  8181. void H225_H324Caps::PrintOn(ostream & strm) const
  8182. {
  8183.   int indent = strm.precision() + 2;
  8184.   strm << "{\n";
  8185.   if (HasOptionalField(e_nonStandardData))
  8186.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8187.   if (HasOptionalField(e_dataRatesSupported))
  8188.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  8189.   if (HasOptionalField(e_supportedPrefixes))
  8190.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  8191.   strm << setw(indent-1) << "}";
  8192. }
  8193. #endif
  8194.  
  8195.  
  8196. PObject::Comparison H225_H324Caps::Compare(const PObject & obj) const
  8197. {
  8198. #ifndef PASN_LEANANDMEAN
  8199.   PAssert(IsDescendant(H225_H324Caps::Class()), PInvalidCast);
  8200. #endif
  8201.   const H225_H324Caps & other = (const H225_H324Caps &)obj;
  8202.  
  8203.   Comparison result;
  8204.  
  8205.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8206.     return result;
  8207.  
  8208.   return PASN_Sequence::Compare(other);
  8209. }
  8210.  
  8211.  
  8212. PINDEX H225_H324Caps::GetDataLength() const
  8213. {
  8214.   PINDEX length = 0;
  8215.   if (HasOptionalField(e_nonStandardData))
  8216.     length += m_nonStandardData.GetObjectLength();
  8217.   return length;
  8218. }
  8219.  
  8220.  
  8221. BOOL H225_H324Caps::Decode(PASN_Stream & strm)
  8222. {
  8223.   if (!PreambleDecode(strm))
  8224.     return FALSE;
  8225.  
  8226.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8227.     return FALSE;
  8228.   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
  8229.     return FALSE;
  8230.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  8231.     return FALSE;
  8232.  
  8233.   return UnknownExtensionsDecode(strm);
  8234. }
  8235.  
  8236.  
  8237. void H225_H324Caps::Encode(PASN_Stream & strm) const
  8238. {
  8239.   PreambleEncode(strm);
  8240.  
  8241.   if (HasOptionalField(e_nonStandardData))
  8242.     m_nonStandardData.Encode(strm);
  8243.   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
  8244.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  8245.  
  8246.   UnknownExtensionsEncode(strm);
  8247. }
  8248.  
  8249.  
  8250. PObject * H225_H324Caps::Clone() const
  8251. {
  8252. #ifndef PASN_LEANANDMEAN
  8253.   PAssert(IsClass(H225_H324Caps::Class()), PInvalidCast);
  8254. #endif
  8255.   return new H225_H324Caps(*this);
  8256. }
  8257.  
  8258.  
  8259. //
  8260. // VoiceCaps
  8261. //
  8262.  
  8263. H225_VoiceCaps::H225_VoiceCaps(unsigned tag, PASN_Object::TagClass tagClass)
  8264.   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
  8265. {
  8266.   IncludeOptionalField(e_supportedPrefixes);
  8267. }
  8268.  
  8269.  
  8270. #ifndef PASN_NOPRINTON
  8271. void H225_VoiceCaps::PrintOn(ostream & strm) const
  8272. {
  8273.   int indent = strm.precision() + 2;
  8274.   strm << "{\n";
  8275.   if (HasOptionalField(e_nonStandardData))
  8276.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8277.   if (HasOptionalField(e_dataRatesSupported))
  8278.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  8279.   if (HasOptionalField(e_supportedPrefixes))
  8280.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  8281.   strm << setw(indent-1) << "}";
  8282. }
  8283. #endif
  8284.  
  8285.  
  8286. PObject::Comparison H225_VoiceCaps::Compare(const PObject & obj) const
  8287. {
  8288. #ifndef PASN_LEANANDMEAN
  8289.   PAssert(IsDescendant(H225_VoiceCaps::Class()), PInvalidCast);
  8290. #endif
  8291.   const H225_VoiceCaps & other = (const H225_VoiceCaps &)obj;
  8292.  
  8293.   Comparison result;
  8294.  
  8295.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8296.     return result;
  8297.  
  8298.   return PASN_Sequence::Compare(other);
  8299. }
  8300.  
  8301.  
  8302. PINDEX H225_VoiceCaps::GetDataLength() const
  8303. {
  8304.   PINDEX length = 0;
  8305.   if (HasOptionalField(e_nonStandardData))
  8306.     length += m_nonStandardData.GetObjectLength();
  8307.   return length;
  8308. }
  8309.  
  8310.  
  8311. BOOL H225_VoiceCaps::Decode(PASN_Stream & strm)
  8312. {
  8313.   if (!PreambleDecode(strm))
  8314.     return FALSE;
  8315.  
  8316.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8317.     return FALSE;
  8318.   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
  8319.     return FALSE;
  8320.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  8321.     return FALSE;
  8322.  
  8323.   return UnknownExtensionsDecode(strm);
  8324. }
  8325.  
  8326.  
  8327. void H225_VoiceCaps::Encode(PASN_Stream & strm) const
  8328. {
  8329.   PreambleEncode(strm);
  8330.  
  8331.   if (HasOptionalField(e_nonStandardData))
  8332.     m_nonStandardData.Encode(strm);
  8333.   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
  8334.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  8335.  
  8336.   UnknownExtensionsEncode(strm);
  8337. }
  8338.  
  8339.  
  8340. PObject * H225_VoiceCaps::Clone() const
  8341. {
  8342. #ifndef PASN_LEANANDMEAN
  8343.   PAssert(IsClass(H225_VoiceCaps::Class()), PInvalidCast);
  8344. #endif
  8345.   return new H225_VoiceCaps(*this);
  8346. }
  8347.  
  8348.  
  8349. //
  8350. // T120OnlyCaps
  8351. //
  8352.  
  8353. H225_T120OnlyCaps::H225_T120OnlyCaps(unsigned tag, PASN_Object::TagClass tagClass)
  8354.   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
  8355. {
  8356.   IncludeOptionalField(e_supportedPrefixes);
  8357. }
  8358.  
  8359.  
  8360. #ifndef PASN_NOPRINTON
  8361. void H225_T120OnlyCaps::PrintOn(ostream & strm) const
  8362. {
  8363.   int indent = strm.precision() + 2;
  8364.   strm << "{\n";
  8365.   if (HasOptionalField(e_nonStandardData))
  8366.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8367.   if (HasOptionalField(e_dataRatesSupported))
  8368.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  8369.   if (HasOptionalField(e_supportedPrefixes))
  8370.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  8371.   strm << setw(indent-1) << "}";
  8372. }
  8373. #endif
  8374.  
  8375.  
  8376. PObject::Comparison H225_T120OnlyCaps::Compare(const PObject & obj) const
  8377. {
  8378. #ifndef PASN_LEANANDMEAN
  8379.   PAssert(IsDescendant(H225_T120OnlyCaps::Class()), PInvalidCast);
  8380. #endif
  8381.   const H225_T120OnlyCaps & other = (const H225_T120OnlyCaps &)obj;
  8382.  
  8383.   Comparison result;
  8384.  
  8385.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8386.     return result;
  8387.  
  8388.   return PASN_Sequence::Compare(other);
  8389. }
  8390.  
  8391.  
  8392. PINDEX H225_T120OnlyCaps::GetDataLength() const
  8393. {
  8394.   PINDEX length = 0;
  8395.   if (HasOptionalField(e_nonStandardData))
  8396.     length += m_nonStandardData.GetObjectLength();
  8397.   return length;
  8398. }
  8399.  
  8400.  
  8401. BOOL H225_T120OnlyCaps::Decode(PASN_Stream & strm)
  8402. {
  8403.   if (!PreambleDecode(strm))
  8404.     return FALSE;
  8405.  
  8406.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8407.     return FALSE;
  8408.   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
  8409.     return FALSE;
  8410.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  8411.     return FALSE;
  8412.  
  8413.   return UnknownExtensionsDecode(strm);
  8414. }
  8415.  
  8416.  
  8417. void H225_T120OnlyCaps::Encode(PASN_Stream & strm) const
  8418. {
  8419.   PreambleEncode(strm);
  8420.  
  8421.   if (HasOptionalField(e_nonStandardData))
  8422.     m_nonStandardData.Encode(strm);
  8423.   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
  8424.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  8425.  
  8426.   UnknownExtensionsEncode(strm);
  8427. }
  8428.  
  8429.  
  8430. PObject * H225_T120OnlyCaps::Clone() const
  8431. {
  8432. #ifndef PASN_LEANANDMEAN
  8433.   PAssert(IsClass(H225_T120OnlyCaps::Class()), PInvalidCast);
  8434. #endif
  8435.   return new H225_T120OnlyCaps(*this);
  8436. }
  8437.  
  8438.  
  8439. //
  8440. // NonStandardProtocol
  8441. //
  8442.  
  8443. H225_NonStandardProtocol::H225_NonStandardProtocol(unsigned tag, PASN_Object::TagClass tagClass)
  8444.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  8445. {
  8446. }
  8447.  
  8448.  
  8449. #ifndef PASN_NOPRINTON
  8450. void H225_NonStandardProtocol::PrintOn(ostream & strm) const
  8451. {
  8452.   int indent = strm.precision() + 2;
  8453.   strm << "{\n";
  8454.   if (HasOptionalField(e_nonStandardData))
  8455.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8456.   if (HasOptionalField(e_dataRatesSupported))
  8457.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  8458.   strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  8459.   strm << setw(indent-1) << "}";
  8460. }
  8461. #endif
  8462.  
  8463.  
  8464. PObject::Comparison H225_NonStandardProtocol::Compare(const PObject & obj) const
  8465. {
  8466. #ifndef PASN_LEANANDMEAN
  8467.   PAssert(IsDescendant(H225_NonStandardProtocol::Class()), PInvalidCast);
  8468. #endif
  8469.   const H225_NonStandardProtocol & other = (const H225_NonStandardProtocol &)obj;
  8470.  
  8471.   Comparison result;
  8472.  
  8473.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8474.     return result;
  8475.   if ((result = m_dataRatesSupported.Compare(other.m_dataRatesSupported)) != EqualTo)
  8476.     return result;
  8477.   if ((result = m_supportedPrefixes.Compare(other.m_supportedPrefixes)) != EqualTo)
  8478.     return result;
  8479.  
  8480.   return PASN_Sequence::Compare(other);
  8481. }
  8482.  
  8483.  
  8484. PINDEX H225_NonStandardProtocol::GetDataLength() const
  8485. {
  8486.   PINDEX length = 0;
  8487.   if (HasOptionalField(e_nonStandardData))
  8488.     length += m_nonStandardData.GetObjectLength();
  8489.   if (HasOptionalField(e_dataRatesSupported))
  8490.     length += m_dataRatesSupported.GetObjectLength();
  8491.   length += m_supportedPrefixes.GetObjectLength();
  8492.   return length;
  8493. }
  8494.  
  8495.  
  8496. BOOL H225_NonStandardProtocol::Decode(PASN_Stream & strm)
  8497. {
  8498.   if (!PreambleDecode(strm))
  8499.     return FALSE;
  8500.  
  8501.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8502.     return FALSE;
  8503.   if (HasOptionalField(e_dataRatesSupported) && !m_dataRatesSupported.Decode(strm))
  8504.     return FALSE;
  8505.   if (!m_supportedPrefixes.Decode(strm))
  8506.     return FALSE;
  8507.  
  8508.   return UnknownExtensionsDecode(strm);
  8509. }
  8510.  
  8511.  
  8512. void H225_NonStandardProtocol::Encode(PASN_Stream & strm) const
  8513. {
  8514.   PreambleEncode(strm);
  8515.  
  8516.   if (HasOptionalField(e_nonStandardData))
  8517.     m_nonStandardData.Encode(strm);
  8518.   if (HasOptionalField(e_dataRatesSupported))
  8519.     m_dataRatesSupported.Encode(strm);
  8520.   m_supportedPrefixes.Encode(strm);
  8521.  
  8522.   UnknownExtensionsEncode(strm);
  8523. }
  8524.  
  8525.  
  8526. PObject * H225_NonStandardProtocol::Clone() const
  8527. {
  8528. #ifndef PASN_LEANANDMEAN
  8529.   PAssert(IsClass(H225_NonStandardProtocol::Class()), PInvalidCast);
  8530. #endif
  8531.   return new H225_NonStandardProtocol(*this);
  8532. }
  8533.  
  8534.  
  8535. //
  8536. // T38FaxAnnexbOnlyCaps
  8537. //
  8538.  
  8539. H225_T38FaxAnnexbOnlyCaps::H225_T38FaxAnnexbOnlyCaps(unsigned tag, PASN_Object::TagClass tagClass)
  8540.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  8541. {
  8542. }
  8543.  
  8544.  
  8545. #ifndef PASN_NOPRINTON
  8546. void H225_T38FaxAnnexbOnlyCaps::PrintOn(ostream & strm) const
  8547. {
  8548.   int indent = strm.precision() + 2;
  8549.   strm << "{\n";
  8550.   if (HasOptionalField(e_nonStandardData))
  8551.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8552.   if (HasOptionalField(e_dataRatesSupported))
  8553.     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
  8554.   strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  8555.   strm << setw(indent+17) << "t38FaxProtocol = " << setprecision(indent) << m_t38FaxProtocol << '\n';
  8556.   strm << setw(indent+16) << "t38FaxProfile = " << setprecision(indent) << m_t38FaxProfile << '\n';
  8557.   strm << setw(indent-1) << "}";
  8558. }
  8559. #endif
  8560.  
  8561.  
  8562. PObject::Comparison H225_T38FaxAnnexbOnlyCaps::Compare(const PObject & obj) const
  8563. {
  8564. #ifndef PASN_LEANANDMEAN
  8565.   PAssert(IsDescendant(H225_T38FaxAnnexbOnlyCaps::Class()), PInvalidCast);
  8566. #endif
  8567.   const H225_T38FaxAnnexbOnlyCaps & other = (const H225_T38FaxAnnexbOnlyCaps &)obj;
  8568.  
  8569.   Comparison result;
  8570.  
  8571.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8572.     return result;
  8573.   if ((result = m_dataRatesSupported.Compare(other.m_dataRatesSupported)) != EqualTo)
  8574.     return result;
  8575.   if ((result = m_supportedPrefixes.Compare(other.m_supportedPrefixes)) != EqualTo)
  8576.     return result;
  8577.   if ((result = m_t38FaxProtocol.Compare(other.m_t38FaxProtocol)) != EqualTo)
  8578.     return result;
  8579.   if ((result = m_t38FaxProfile.Compare(other.m_t38FaxProfile)) != EqualTo)
  8580.     return result;
  8581.  
  8582.   return PASN_Sequence::Compare(other);
  8583. }
  8584.  
  8585.  
  8586. PINDEX H225_T38FaxAnnexbOnlyCaps::GetDataLength() const
  8587. {
  8588.   PINDEX length = 0;
  8589.   if (HasOptionalField(e_nonStandardData))
  8590.     length += m_nonStandardData.GetObjectLength();
  8591.   if (HasOptionalField(e_dataRatesSupported))
  8592.     length += m_dataRatesSupported.GetObjectLength();
  8593.   length += m_supportedPrefixes.GetObjectLength();
  8594.   length += m_t38FaxProtocol.GetObjectLength();
  8595.   length += m_t38FaxProfile.GetObjectLength();
  8596.   return length;
  8597. }
  8598.  
  8599.  
  8600. BOOL H225_T38FaxAnnexbOnlyCaps::Decode(PASN_Stream & strm)
  8601. {
  8602.   if (!PreambleDecode(strm))
  8603.     return FALSE;
  8604.  
  8605.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8606.     return FALSE;
  8607.   if (HasOptionalField(e_dataRatesSupported) && !m_dataRatesSupported.Decode(strm))
  8608.     return FALSE;
  8609.   if (!m_supportedPrefixes.Decode(strm))
  8610.     return FALSE;
  8611.   if (!m_t38FaxProtocol.Decode(strm))
  8612.     return FALSE;
  8613.   if (!m_t38FaxProfile.Decode(strm))
  8614.     return FALSE;
  8615.  
  8616.   return UnknownExtensionsDecode(strm);
  8617. }
  8618.  
  8619.  
  8620. void H225_T38FaxAnnexbOnlyCaps::Encode(PASN_Stream & strm) const
  8621. {
  8622.   PreambleEncode(strm);
  8623.  
  8624.   if (HasOptionalField(e_nonStandardData))
  8625.     m_nonStandardData.Encode(strm);
  8626.   if (HasOptionalField(e_dataRatesSupported))
  8627.     m_dataRatesSupported.Encode(strm);
  8628.   m_supportedPrefixes.Encode(strm);
  8629.   m_t38FaxProtocol.Encode(strm);
  8630.   m_t38FaxProfile.Encode(strm);
  8631.  
  8632.   UnknownExtensionsEncode(strm);
  8633. }
  8634.  
  8635.  
  8636. PObject * H225_T38FaxAnnexbOnlyCaps::Clone() const
  8637. {
  8638. #ifndef PASN_LEANANDMEAN
  8639.   PAssert(IsClass(H225_T38FaxAnnexbOnlyCaps::Class()), PInvalidCast);
  8640. #endif
  8641.   return new H225_T38FaxAnnexbOnlyCaps(*this);
  8642. }
  8643.  
  8644.  
  8645. //
  8646. // McuInfo
  8647. //
  8648.  
  8649. H225_McuInfo::H225_McuInfo(unsigned tag, PASN_Object::TagClass tagClass)
  8650.   : PASN_Sequence(tag, tagClass, 1, TRUE, 1)
  8651. {
  8652. }
  8653.  
  8654.  
  8655. #ifndef PASN_NOPRINTON
  8656. void H225_McuInfo::PrintOn(ostream & strm) const
  8657. {
  8658.   int indent = strm.precision() + 2;
  8659.   strm << "{\n";
  8660.   if (HasOptionalField(e_nonStandardData))
  8661.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8662.   if (HasOptionalField(e_protocol))
  8663.     strm << setw(indent+11) << "protocol = " << setprecision(indent) << m_protocol << '\n';
  8664.   strm << setw(indent-1) << "}";
  8665. }
  8666. #endif
  8667.  
  8668.  
  8669. PObject::Comparison H225_McuInfo::Compare(const PObject & obj) const
  8670. {
  8671. #ifndef PASN_LEANANDMEAN
  8672.   PAssert(IsDescendant(H225_McuInfo::Class()), PInvalidCast);
  8673. #endif
  8674.   const H225_McuInfo & other = (const H225_McuInfo &)obj;
  8675.  
  8676.   Comparison result;
  8677.  
  8678.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8679.     return result;
  8680.  
  8681.   return PASN_Sequence::Compare(other);
  8682. }
  8683.  
  8684.  
  8685. PINDEX H225_McuInfo::GetDataLength() const
  8686. {
  8687.   PINDEX length = 0;
  8688.   if (HasOptionalField(e_nonStandardData))
  8689.     length += m_nonStandardData.GetObjectLength();
  8690.   return length;
  8691. }
  8692.  
  8693.  
  8694. BOOL H225_McuInfo::Decode(PASN_Stream & strm)
  8695. {
  8696.   if (!PreambleDecode(strm))
  8697.     return FALSE;
  8698.  
  8699.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8700.     return FALSE;
  8701.   if (!KnownExtensionDecode(strm, e_protocol, m_protocol))
  8702.     return FALSE;
  8703.  
  8704.   return UnknownExtensionsDecode(strm);
  8705. }
  8706.  
  8707.  
  8708. void H225_McuInfo::Encode(PASN_Stream & strm) const
  8709. {
  8710.   PreambleEncode(strm);
  8711.  
  8712.   if (HasOptionalField(e_nonStandardData))
  8713.     m_nonStandardData.Encode(strm);
  8714.   KnownExtensionEncode(strm, e_protocol, m_protocol);
  8715.  
  8716.   UnknownExtensionsEncode(strm);
  8717. }
  8718.  
  8719.  
  8720. PObject * H225_McuInfo::Clone() const
  8721. {
  8722. #ifndef PASN_LEANANDMEAN
  8723.   PAssert(IsClass(H225_McuInfo::Class()), PInvalidCast);
  8724. #endif
  8725.   return new H225_McuInfo(*this);
  8726. }
  8727.  
  8728.  
  8729. //
  8730. // TerminalInfo
  8731. //
  8732.  
  8733. H225_TerminalInfo::H225_TerminalInfo(unsigned tag, PASN_Object::TagClass tagClass)
  8734.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  8735. {
  8736. }
  8737.  
  8738.  
  8739. #ifndef PASN_NOPRINTON
  8740. void H225_TerminalInfo::PrintOn(ostream & strm) const
  8741. {
  8742.   int indent = strm.precision() + 2;
  8743.   strm << "{\n";
  8744.   if (HasOptionalField(e_nonStandardData))
  8745.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8746.   strm << setw(indent-1) << "}";
  8747. }
  8748. #endif
  8749.  
  8750.  
  8751. PObject::Comparison H225_TerminalInfo::Compare(const PObject & obj) const
  8752. {
  8753. #ifndef PASN_LEANANDMEAN
  8754.   PAssert(IsDescendant(H225_TerminalInfo::Class()), PInvalidCast);
  8755. #endif
  8756.   const H225_TerminalInfo & other = (const H225_TerminalInfo &)obj;
  8757.  
  8758.   Comparison result;
  8759.  
  8760.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8761.     return result;
  8762.  
  8763.   return PASN_Sequence::Compare(other);
  8764. }
  8765.  
  8766.  
  8767. PINDEX H225_TerminalInfo::GetDataLength() const
  8768. {
  8769.   PINDEX length = 0;
  8770.   if (HasOptionalField(e_nonStandardData))
  8771.     length += m_nonStandardData.GetObjectLength();
  8772.   return length;
  8773. }
  8774.  
  8775.  
  8776. BOOL H225_TerminalInfo::Decode(PASN_Stream & strm)
  8777. {
  8778.   if (!PreambleDecode(strm))
  8779.     return FALSE;
  8780.  
  8781.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8782.     return FALSE;
  8783.  
  8784.   return UnknownExtensionsDecode(strm);
  8785. }
  8786.  
  8787.  
  8788. void H225_TerminalInfo::Encode(PASN_Stream & strm) const
  8789. {
  8790.   PreambleEncode(strm);
  8791.  
  8792.   if (HasOptionalField(e_nonStandardData))
  8793.     m_nonStandardData.Encode(strm);
  8794.  
  8795.   UnknownExtensionsEncode(strm);
  8796. }
  8797.  
  8798.  
  8799. PObject * H225_TerminalInfo::Clone() const
  8800. {
  8801. #ifndef PASN_LEANANDMEAN
  8802.   PAssert(IsClass(H225_TerminalInfo::Class()), PInvalidCast);
  8803. #endif
  8804.   return new H225_TerminalInfo(*this);
  8805. }
  8806.  
  8807.  
  8808. //
  8809. // GatekeeperInfo
  8810. //
  8811.  
  8812. H225_GatekeeperInfo::H225_GatekeeperInfo(unsigned tag, PASN_Object::TagClass tagClass)
  8813.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  8814. {
  8815. }
  8816.  
  8817.  
  8818. #ifndef PASN_NOPRINTON
  8819. void H225_GatekeeperInfo::PrintOn(ostream & strm) const
  8820. {
  8821.   int indent = strm.precision() + 2;
  8822.   strm << "{\n";
  8823.   if (HasOptionalField(e_nonStandardData))
  8824.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  8825.   strm << setw(indent-1) << "}";
  8826. }
  8827. #endif
  8828.  
  8829.  
  8830. PObject::Comparison H225_GatekeeperInfo::Compare(const PObject & obj) const
  8831. {
  8832. #ifndef PASN_LEANANDMEAN
  8833.   PAssert(IsDescendant(H225_GatekeeperInfo::Class()), PInvalidCast);
  8834. #endif
  8835.   const H225_GatekeeperInfo & other = (const H225_GatekeeperInfo &)obj;
  8836.  
  8837.   Comparison result;
  8838.  
  8839.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  8840.     return result;
  8841.  
  8842.   return PASN_Sequence::Compare(other);
  8843. }
  8844.  
  8845.  
  8846. PINDEX H225_GatekeeperInfo::GetDataLength() const
  8847. {
  8848.   PINDEX length = 0;
  8849.   if (HasOptionalField(e_nonStandardData))
  8850.     length += m_nonStandardData.GetObjectLength();
  8851.   return length;
  8852. }
  8853.  
  8854.  
  8855. BOOL H225_GatekeeperInfo::Decode(PASN_Stream & strm)
  8856. {
  8857.   if (!PreambleDecode(strm))
  8858.     return FALSE;
  8859.  
  8860.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  8861.     return FALSE;
  8862.  
  8863.   return UnknownExtensionsDecode(strm);
  8864. }
  8865.  
  8866.  
  8867. void H225_GatekeeperInfo::Encode(PASN_Stream & strm) const
  8868. {
  8869.   PreambleEncode(strm);
  8870.  
  8871.   if (HasOptionalField(e_nonStandardData))
  8872.     m_nonStandardData.Encode(strm);
  8873.  
  8874.   UnknownExtensionsEncode(strm);
  8875. }
  8876.  
  8877.  
  8878. PObject * H225_GatekeeperInfo::Clone() const
  8879. {
  8880. #ifndef PASN_LEANANDMEAN
  8881.   PAssert(IsClass(H225_GatekeeperInfo::Class()), PInvalidCast);
  8882. #endif
  8883.   return new H225_GatekeeperInfo(*this);
  8884. }
  8885.  
  8886.  
  8887. //
  8888. // FeatureDescriptor
  8889. //
  8890.  
  8891. H225_FeatureDescriptor::H225_FeatureDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
  8892.   : H225_GenericData(tag, tagClass)
  8893. {
  8894. }
  8895.  
  8896.  
  8897. PObject * H225_FeatureDescriptor::Clone() const
  8898. {
  8899. #ifndef PASN_LEANANDMEAN
  8900.   PAssert(IsClass(H225_FeatureDescriptor::Class()), PInvalidCast);
  8901. #endif
  8902.   return new H225_FeatureDescriptor(*this);
  8903. }
  8904.  
  8905.  
  8906. //
  8907. // CallCapacity
  8908. //
  8909.  
  8910. H225_CallCapacity::H225_CallCapacity(unsigned tag, PASN_Object::TagClass tagClass)
  8911.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  8912. {
  8913. }
  8914.  
  8915.  
  8916. #ifndef PASN_NOPRINTON
  8917. void H225_CallCapacity::PrintOn(ostream & strm) const
  8918. {
  8919.   int indent = strm.precision() + 2;
  8920.   strm << "{\n";
  8921.   if (HasOptionalField(e_maximumCallCapacity))
  8922.     strm << setw(indent+22) << "maximumCallCapacity = " << setprecision(indent) << m_maximumCallCapacity << '\n';
  8923.   if (HasOptionalField(e_currentCallCapacity))
  8924.     strm << setw(indent+22) << "currentCallCapacity = " << setprecision(indent) << m_currentCallCapacity << '\n';
  8925.   strm << setw(indent-1) << "}";
  8926. }
  8927. #endif
  8928.  
  8929.  
  8930. PObject::Comparison H225_CallCapacity::Compare(const PObject & obj) const
  8931. {
  8932. #ifndef PASN_LEANANDMEAN
  8933.   PAssert(IsDescendant(H225_CallCapacity::Class()), PInvalidCast);
  8934. #endif
  8935.   const H225_CallCapacity & other = (const H225_CallCapacity &)obj;
  8936.  
  8937.   Comparison result;
  8938.  
  8939.   if ((result = m_maximumCallCapacity.Compare(other.m_maximumCallCapacity)) != EqualTo)
  8940.     return result;
  8941.   if ((result = m_currentCallCapacity.Compare(other.m_currentCallCapacity)) != EqualTo)
  8942.     return result;
  8943.  
  8944.   return PASN_Sequence::Compare(other);
  8945. }
  8946.  
  8947.  
  8948. PINDEX H225_CallCapacity::GetDataLength() const
  8949. {
  8950.   PINDEX length = 0;
  8951.   if (HasOptionalField(e_maximumCallCapacity))
  8952.     length += m_maximumCallCapacity.GetObjectLength();
  8953.   if (HasOptionalField(e_currentCallCapacity))
  8954.     length += m_currentCallCapacity.GetObjectLength();
  8955.   return length;
  8956. }
  8957.  
  8958.  
  8959. BOOL H225_CallCapacity::Decode(PASN_Stream & strm)
  8960. {
  8961.   if (!PreambleDecode(strm))
  8962.     return FALSE;
  8963.  
  8964.   if (HasOptionalField(e_maximumCallCapacity) && !m_maximumCallCapacity.Decode(strm))
  8965.     return FALSE;
  8966.   if (HasOptionalField(e_currentCallCapacity) && !m_currentCallCapacity.Decode(strm))
  8967.     return FALSE;
  8968.  
  8969.   return UnknownExtensionsDecode(strm);
  8970. }
  8971.  
  8972.  
  8973. void H225_CallCapacity::Encode(PASN_Stream & strm) const
  8974. {
  8975.   PreambleEncode(strm);
  8976.  
  8977.   if (HasOptionalField(e_maximumCallCapacity))
  8978.     m_maximumCallCapacity.Encode(strm);
  8979.   if (HasOptionalField(e_currentCallCapacity))
  8980.     m_currentCallCapacity.Encode(strm);
  8981.  
  8982.   UnknownExtensionsEncode(strm);
  8983. }
  8984.  
  8985.  
  8986. PObject * H225_CallCapacity::Clone() const
  8987. {
  8988. #ifndef PASN_LEANANDMEAN
  8989.   PAssert(IsClass(H225_CallCapacity::Class()), PInvalidCast);
  8990. #endif
  8991.   return new H225_CallCapacity(*this);
  8992. }
  8993.  
  8994.  
  8995. //
  8996. // RegistrationConfirm
  8997. //
  8998.  
  8999. H225_RegistrationConfirm::H225_RegistrationConfirm(unsigned tag, PASN_Object::TagClass tagClass)
  9000.   : PASN_Sequence(tag, tagClass, 3, TRUE, 17)
  9001. {
  9002.   IncludeOptionalField(e_willRespondToIRR);
  9003.   IncludeOptionalField(e_maintainConnection);
  9004. }
  9005.  
  9006.  
  9007. #ifndef PASN_NOPRINTON
  9008. void H225_RegistrationConfirm::PrintOn(ostream & strm) const
  9009. {
  9010.   int indent = strm.precision() + 2;
  9011.   strm << "{\n";
  9012.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  9013.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  9014.   if (HasOptionalField(e_nonStandardData))
  9015.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  9016.   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
  9017.   if (HasOptionalField(e_terminalAlias))
  9018.     strm << setw(indent+16) << "terminalAlias = " << setprecision(indent) << m_terminalAlias << '\n';
  9019.   if (HasOptionalField(e_gatekeeperIdentifier))
  9020.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  9021.   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  9022.   if (HasOptionalField(e_alternateGatekeeper))
  9023.     strm << setw(indent+22) << "alternateGatekeeper = " << setprecision(indent) << m_alternateGatekeeper << '\n';
  9024.   if (HasOptionalField(e_timeToLive))
  9025.     strm << setw(indent+13) << "timeToLive = " << setprecision(indent) << m_timeToLive << '\n';
  9026.   if (HasOptionalField(e_tokens))
  9027.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  9028.   if (HasOptionalField(e_cryptoTokens))
  9029.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  9030.   if (HasOptionalField(e_integrityCheckValue))
  9031.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  9032.   if (HasOptionalField(e_willRespondToIRR))
  9033.     strm << setw(indent+19) << "willRespondToIRR = " << setprecision(indent) << m_willRespondToIRR << '\n';
  9034.   if (HasOptionalField(e_preGrantedARQ))
  9035.     strm << setw(indent+16) << "preGrantedARQ = " << setprecision(indent) << m_preGrantedARQ << '\n';
  9036.   if (HasOptionalField(e_maintainConnection))
  9037.     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
  9038.   if (HasOptionalField(e_serviceControl))
  9039.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  9040.   if (HasOptionalField(e_supportsAdditiveRegistration))
  9041.     strm << setw(indent+31) << "supportsAdditiveRegistration = " << setprecision(indent) << m_supportsAdditiveRegistration << '\n';
  9042.   if (HasOptionalField(e_terminalAliasPattern))
  9043.     strm << setw(indent+23) << "terminalAliasPattern = " << setprecision(indent) << m_terminalAliasPattern << '\n';
  9044.   if (HasOptionalField(e_supportedPrefixes))
  9045.     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  9046.   if (HasOptionalField(e_usageSpec))
  9047.     strm << setw(indent+12) << "usageSpec = " << setprecision(indent) << m_usageSpec << '\n';
  9048.   if (HasOptionalField(e_featureServerAlias))
  9049.     strm << setw(indent+21) << "featureServerAlias = " << setprecision(indent) << m_featureServerAlias << '\n';
  9050.   if (HasOptionalField(e_capacityReportingSpec))
  9051.     strm << setw(indent+24) << "capacityReportingSpec = " << setprecision(indent) << m_capacityReportingSpec << '\n';
  9052.   if (HasOptionalField(e_featureSet))
  9053.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  9054.   if (HasOptionalField(e_genericData))
  9055.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  9056.   strm << setw(indent-1) << "}";
  9057. }
  9058. #endif
  9059.  
  9060.  
  9061. PObject::Comparison H225_RegistrationConfirm::Compare(const PObject & obj) const
  9062. {
  9063. #ifndef PASN_LEANANDMEAN
  9064.   PAssert(IsDescendant(H225_RegistrationConfirm::Class()), PInvalidCast);
  9065. #endif
  9066.   const H225_RegistrationConfirm & other = (const H225_RegistrationConfirm &)obj;
  9067.  
  9068.   Comparison result;
  9069.  
  9070.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  9071.     return result;
  9072.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  9073.     return result;
  9074.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  9075.     return result;
  9076.   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
  9077.     return result;
  9078.   if ((result = m_terminalAlias.Compare(other.m_terminalAlias)) != EqualTo)
  9079.     return result;
  9080.   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
  9081.     return result;
  9082.   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
  9083.     return result;
  9084.  
  9085.   return PASN_Sequence::Compare(other);
  9086. }
  9087.  
  9088.  
  9089. PINDEX H225_RegistrationConfirm::GetDataLength() const
  9090. {
  9091.   PINDEX length = 0;
  9092.   length += m_requestSeqNum.GetObjectLength();
  9093.   length += m_protocolIdentifier.GetObjectLength();
  9094.   if (HasOptionalField(e_nonStandardData))
  9095.     length += m_nonStandardData.GetObjectLength();
  9096.   length += m_callSignalAddress.GetObjectLength();
  9097.   if (HasOptionalField(e_terminalAlias))
  9098.     length += m_terminalAlias.GetObjectLength();
  9099.   if (HasOptionalField(e_gatekeeperIdentifier))
  9100.     length += m_gatekeeperIdentifier.GetObjectLength();
  9101.   length += m_endpointIdentifier.GetObjectLength();
  9102.   return length;
  9103. }
  9104.  
  9105.  
  9106. BOOL H225_RegistrationConfirm::Decode(PASN_Stream & strm)
  9107. {
  9108.   if (!PreambleDecode(strm))
  9109.     return FALSE;
  9110.  
  9111.   if (!m_requestSeqNum.Decode(strm))
  9112.     return FALSE;
  9113.   if (!m_protocolIdentifier.Decode(strm))
  9114.     return FALSE;
  9115.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  9116.     return FALSE;
  9117.   if (!m_callSignalAddress.Decode(strm))
  9118.     return FALSE;
  9119.   if (HasOptionalField(e_terminalAlias) && !m_terminalAlias.Decode(strm))
  9120.     return FALSE;
  9121.   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
  9122.     return FALSE;
  9123.   if (!m_endpointIdentifier.Decode(strm))
  9124.     return FALSE;
  9125.   if (!KnownExtensionDecode(strm, e_alternateGatekeeper, m_alternateGatekeeper))
  9126.     return FALSE;
  9127.   if (!KnownExtensionDecode(strm, e_timeToLive, m_timeToLive))
  9128.     return FALSE;
  9129.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  9130.     return FALSE;
  9131.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  9132.     return FALSE;
  9133.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  9134.     return FALSE;
  9135.   if (!KnownExtensionDecode(strm, e_willRespondToIRR, m_willRespondToIRR))
  9136.     return FALSE;
  9137.   if (!KnownExtensionDecode(strm, e_preGrantedARQ, m_preGrantedARQ))
  9138.     return FALSE;
  9139.   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
  9140.     return FALSE;
  9141.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  9142.     return FALSE;
  9143.   if (!KnownExtensionDecode(strm, e_supportsAdditiveRegistration, m_supportsAdditiveRegistration))
  9144.     return FALSE;
  9145.   if (!KnownExtensionDecode(strm, e_terminalAliasPattern, m_terminalAliasPattern))
  9146.     return FALSE;
  9147.   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
  9148.     return FALSE;
  9149.   if (!KnownExtensionDecode(strm, e_usageSpec, m_usageSpec))
  9150.     return FALSE;
  9151.   if (!KnownExtensionDecode(strm, e_featureServerAlias, m_featureServerAlias))
  9152.     return FALSE;
  9153.   if (!KnownExtensionDecode(strm, e_capacityReportingSpec, m_capacityReportingSpec))
  9154.     return FALSE;
  9155.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  9156.     return FALSE;
  9157.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  9158.     return FALSE;
  9159.  
  9160.   return UnknownExtensionsDecode(strm);
  9161. }
  9162.  
  9163.  
  9164. void H225_RegistrationConfirm::Encode(PASN_Stream & strm) const
  9165. {
  9166.   PreambleEncode(strm);
  9167.  
  9168.   m_requestSeqNum.Encode(strm);
  9169.   m_protocolIdentifier.Encode(strm);
  9170.   if (HasOptionalField(e_nonStandardData))
  9171.     m_nonStandardData.Encode(strm);
  9172.   m_callSignalAddress.Encode(strm);
  9173.   if (HasOptionalField(e_terminalAlias))
  9174.     m_terminalAlias.Encode(strm);
  9175.   if (HasOptionalField(e_gatekeeperIdentifier))
  9176.     m_gatekeeperIdentifier.Encode(strm);
  9177.   m_endpointIdentifier.Encode(strm);
  9178.   KnownExtensionEncode(strm, e_alternateGatekeeper, m_alternateGatekeeper);
  9179.   KnownExtensionEncode(strm, e_timeToLive, m_timeToLive);
  9180.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  9181.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  9182.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  9183.   KnownExtensionEncode(strm, e_willRespondToIRR, m_willRespondToIRR);
  9184.   KnownExtensionEncode(strm, e_preGrantedARQ, m_preGrantedARQ);
  9185.   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
  9186.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  9187.   KnownExtensionEncode(strm, e_supportsAdditiveRegistration, m_supportsAdditiveRegistration);
  9188.   KnownExtensionEncode(strm, e_terminalAliasPattern, m_terminalAliasPattern);
  9189.   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
  9190.   KnownExtensionEncode(strm, e_usageSpec, m_usageSpec);
  9191.   KnownExtensionEncode(strm, e_featureServerAlias, m_featureServerAlias);
  9192.   KnownExtensionEncode(strm, e_capacityReportingSpec, m_capacityReportingSpec);
  9193.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  9194.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  9195.  
  9196.   UnknownExtensionsEncode(strm);
  9197. }
  9198.  
  9199.  
  9200. PObject * H225_RegistrationConfirm::Clone() const
  9201. {
  9202. #ifndef PASN_LEANANDMEAN
  9203.   PAssert(IsClass(H225_RegistrationConfirm::Class()), PInvalidCast);
  9204. #endif
  9205.   return new H225_RegistrationConfirm(*this);
  9206. }
  9207.  
  9208.  
  9209. //
  9210. // AdmissionRequest
  9211. //
  9212.  
  9213. H225_AdmissionRequest::H225_AdmissionRequest(unsigned tag, PASN_Object::TagClass tagClass)
  9214.   : PASN_Sequence(tag, tagClass, 7, TRUE, 18)
  9215. {
  9216.   IncludeOptionalField(e_canMapAlias);
  9217.   IncludeOptionalField(e_callIdentifier);
  9218.   IncludeOptionalField(e_willSupplyUUIEs);
  9219. }
  9220.  
  9221.  
  9222. #ifndef PASN_NOPRINTON
  9223. void H225_AdmissionRequest::PrintOn(ostream & strm) const
  9224. {
  9225.   int indent = strm.precision() + 2;
  9226.   strm << "{\n";
  9227.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  9228.   strm << setw(indent+11) << "callType = " << setprecision(indent) << m_callType << '\n';
  9229.   if (HasOptionalField(e_callModel))
  9230.     strm << setw(indent+12) << "callModel = " << setprecision(indent) << m_callModel << '\n';
  9231.   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  9232.   if (HasOptionalField(e_destinationInfo))
  9233.     strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
  9234.   if (HasOptionalField(e_destCallSignalAddress))
  9235.     strm << setw(indent+24) << "destCallSignalAddress = " << setprecision(indent) << m_destCallSignalAddress << '\n';
  9236.   if (HasOptionalField(e_destExtraCallInfo))
  9237.     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
  9238.   strm << setw(indent+10) << "srcInfo = " << setprecision(indent) << m_srcInfo << '\n';
  9239.   if (HasOptionalField(e_srcCallSignalAddress))
  9240.     strm << setw(indent+23) << "srcCallSignalAddress = " << setprecision(indent) << m_srcCallSignalAddress << '\n';
  9241.   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
  9242.   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
  9243.   if (HasOptionalField(e_nonStandardData))
  9244.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  9245.   if (HasOptionalField(e_callServices))
  9246.     strm << setw(indent+15) << "callServices = " << setprecision(indent) << m_callServices << '\n';
  9247.   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  9248.   strm << setw(indent+11) << "activeMC = " << setprecision(indent) << m_activeMC << '\n';
  9249.   strm << setw(indent+13) << "answerCall = " << setprecision(indent) << m_answerCall << '\n';
  9250.   if (HasOptionalField(e_canMapAlias))
  9251.     strm << setw(indent+14) << "canMapAlias = " << setprecision(indent) << m_canMapAlias << '\n';
  9252.   if (HasOptionalField(e_callIdentifier))
  9253.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  9254.   if (HasOptionalField(e_srcAlternatives))
  9255.     strm << setw(indent+18) << "srcAlternatives = " << setprecision(indent) << m_srcAlternatives << '\n';
  9256.   if (HasOptionalField(e_destAlternatives))
  9257.     strm << setw(indent+19) << "destAlternatives = " << setprecision(indent) << m_destAlternatives << '\n';
  9258.   if (HasOptionalField(e_gatekeeperIdentifier))
  9259.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  9260.   if (HasOptionalField(e_tokens))
  9261.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  9262.   if (HasOptionalField(e_cryptoTokens))
  9263.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  9264.   if (HasOptionalField(e_integrityCheckValue))
  9265.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  9266.   if (HasOptionalField(e_transportQOS))
  9267.     strm << setw(indent+15) << "transportQOS = " << setprecision(indent) << m_transportQOS << '\n';
  9268.   if (HasOptionalField(e_willSupplyUUIEs))
  9269.     strm << setw(indent+18) << "willSupplyUUIEs = " << setprecision(indent) << m_willSupplyUUIEs << '\n';
  9270.   if (HasOptionalField(e_callLinkage))
  9271.     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
  9272.   if (HasOptionalField(e_gatewayDataRate))
  9273.     strm << setw(indent+18) << "gatewayDataRate = " << setprecision(indent) << m_gatewayDataRate << '\n';
  9274.   if (HasOptionalField(e_capacity))
  9275.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  9276.   if (HasOptionalField(e_circuitInfo))
  9277.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  9278.   if (HasOptionalField(e_desiredProtocols))
  9279.     strm << setw(indent+19) << "desiredProtocols = " << setprecision(indent) << m_desiredProtocols << '\n';
  9280.   if (HasOptionalField(e_desiredTunnelledProtocol))
  9281.     strm << setw(indent+27) << "desiredTunnelledProtocol = " << setprecision(indent) << m_desiredTunnelledProtocol << '\n';
  9282.   if (HasOptionalField(e_featureSet))
  9283.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  9284.   if (HasOptionalField(e_genericData))
  9285.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  9286.   strm << setw(indent-1) << "}";
  9287. }
  9288. #endif
  9289.  
  9290.  
  9291. PObject::Comparison H225_AdmissionRequest::Compare(const PObject & obj) const
  9292. {
  9293. #ifndef PASN_LEANANDMEAN
  9294.   PAssert(IsDescendant(H225_AdmissionRequest::Class()), PInvalidCast);
  9295. #endif
  9296.   const H225_AdmissionRequest & other = (const H225_AdmissionRequest &)obj;
  9297.  
  9298.   Comparison result;
  9299.  
  9300.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  9301.     return result;
  9302.   if ((result = m_callType.Compare(other.m_callType)) != EqualTo)
  9303.     return result;
  9304.   if ((result = m_callModel.Compare(other.m_callModel)) != EqualTo)
  9305.     return result;
  9306.   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
  9307.     return result;
  9308.   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
  9309.     return result;
  9310.   if ((result = m_destCallSignalAddress.Compare(other.m_destCallSignalAddress)) != EqualTo)
  9311.     return result;
  9312.   if ((result = m_destExtraCallInfo.Compare(other.m_destExtraCallInfo)) != EqualTo)
  9313.     return result;
  9314.   if ((result = m_srcInfo.Compare(other.m_srcInfo)) != EqualTo)
  9315.     return result;
  9316.   if ((result = m_srcCallSignalAddress.Compare(other.m_srcCallSignalAddress)) != EqualTo)
  9317.     return result;
  9318.   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
  9319.     return result;
  9320.   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
  9321.     return result;
  9322.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  9323.     return result;
  9324.   if ((result = m_callServices.Compare(other.m_callServices)) != EqualTo)
  9325.     return result;
  9326.   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
  9327.     return result;
  9328.   if ((result = m_activeMC.Compare(other.m_activeMC)) != EqualTo)
  9329.     return result;
  9330.   if ((result = m_answerCall.Compare(other.m_answerCall)) != EqualTo)
  9331.     return result;
  9332.  
  9333.   return PASN_Sequence::Compare(other);
  9334. }
  9335.  
  9336.  
  9337. PINDEX H225_AdmissionRequest::GetDataLength() const
  9338. {
  9339.   PINDEX length = 0;
  9340.   length += m_requestSeqNum.GetObjectLength();
  9341.   length += m_callType.GetObjectLength();
  9342.   if (HasOptionalField(e_callModel))
  9343.     length += m_callModel.GetObjectLength();
  9344.   length += m_endpointIdentifier.GetObjectLength();
  9345.   if (HasOptionalField(e_destinationInfo))
  9346.     length += m_destinationInfo.GetObjectLength();
  9347.   if (HasOptionalField(e_destCallSignalAddress))
  9348.     length += m_destCallSignalAddress.GetObjectLength();
  9349.   if (HasOptionalField(e_destExtraCallInfo))
  9350.     length += m_destExtraCallInfo.GetObjectLength();
  9351.   length += m_srcInfo.GetObjectLength();
  9352.   if (HasOptionalField(e_srcCallSignalAddress))
  9353.     length += m_srcCallSignalAddress.GetObjectLength();
  9354.   length += m_bandWidth.GetObjectLength();
  9355.   length += m_callReferenceValue.GetObjectLength();
  9356.   if (HasOptionalField(e_nonStandardData))
  9357.     length += m_nonStandardData.GetObjectLength();
  9358.   if (HasOptionalField(e_callServices))
  9359.     length += m_callServices.GetObjectLength();
  9360.   length += m_conferenceID.GetObjectLength();
  9361.   length += m_activeMC.GetObjectLength();
  9362.   length += m_answerCall.GetObjectLength();
  9363.   return length;
  9364. }
  9365.  
  9366.  
  9367. BOOL H225_AdmissionRequest::Decode(PASN_Stream & strm)
  9368. {
  9369.   if (!PreambleDecode(strm))
  9370.     return FALSE;
  9371.  
  9372.   if (!m_requestSeqNum.Decode(strm))
  9373.     return FALSE;
  9374.   if (!m_callType.Decode(strm))
  9375.     return FALSE;
  9376.   if (HasOptionalField(e_callModel) && !m_callModel.Decode(strm))
  9377.     return FALSE;
  9378.   if (!m_endpointIdentifier.Decode(strm))
  9379.     return FALSE;
  9380.   if (HasOptionalField(e_destinationInfo) && !m_destinationInfo.Decode(strm))
  9381.     return FALSE;
  9382.   if (HasOptionalField(e_destCallSignalAddress) && !m_destCallSignalAddress.Decode(strm))
  9383.     return FALSE;
  9384.   if (HasOptionalField(e_destExtraCallInfo) && !m_destExtraCallInfo.Decode(strm))
  9385.     return FALSE;
  9386.   if (!m_srcInfo.Decode(strm))
  9387.     return FALSE;
  9388.   if (HasOptionalField(e_srcCallSignalAddress) && !m_srcCallSignalAddress.Decode(strm))
  9389.     return FALSE;
  9390.   if (!m_bandWidth.Decode(strm))
  9391.     return FALSE;
  9392.   if (!m_callReferenceValue.Decode(strm))
  9393.     return FALSE;
  9394.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  9395.     return FALSE;
  9396.   if (HasOptionalField(e_callServices) && !m_callServices.Decode(strm))
  9397.     return FALSE;
  9398.   if (!m_conferenceID.Decode(strm))
  9399.     return FALSE;
  9400.   if (!m_activeMC.Decode(strm))
  9401.     return FALSE;
  9402.   if (!m_answerCall.Decode(strm))
  9403.     return FALSE;
  9404.   if (!KnownExtensionDecode(strm, e_canMapAlias, m_canMapAlias))
  9405.     return FALSE;
  9406.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  9407.     return FALSE;
  9408.   if (!KnownExtensionDecode(strm, e_srcAlternatives, m_srcAlternatives))
  9409.     return FALSE;
  9410.   if (!KnownExtensionDecode(strm, e_destAlternatives, m_destAlternatives))
  9411.     return FALSE;
  9412.   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
  9413.     return FALSE;
  9414.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  9415.     return FALSE;
  9416.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  9417.     return FALSE;
  9418.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  9419.     return FALSE;
  9420.   if (!KnownExtensionDecode(strm, e_transportQOS, m_transportQOS))
  9421.     return FALSE;
  9422.   if (!KnownExtensionDecode(strm, e_willSupplyUUIEs, m_willSupplyUUIEs))
  9423.     return FALSE;
  9424.   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
  9425.     return FALSE;
  9426.   if (!KnownExtensionDecode(strm, e_gatewayDataRate, m_gatewayDataRate))
  9427.     return FALSE;
  9428.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  9429.     return FALSE;
  9430.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  9431.     return FALSE;
  9432.   if (!KnownExtensionDecode(strm, e_desiredProtocols, m_desiredProtocols))
  9433.     return FALSE;
  9434.   if (!KnownExtensionDecode(strm, e_desiredTunnelledProtocol, m_desiredTunnelledProtocol))
  9435.     return FALSE;
  9436.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  9437.     return FALSE;
  9438.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  9439.     return FALSE;
  9440.  
  9441.   return UnknownExtensionsDecode(strm);
  9442. }
  9443.  
  9444.  
  9445. void H225_AdmissionRequest::Encode(PASN_Stream & strm) const
  9446. {
  9447.   PreambleEncode(strm);
  9448.  
  9449.   m_requestSeqNum.Encode(strm);
  9450.   m_callType.Encode(strm);
  9451.   if (HasOptionalField(e_callModel))
  9452.     m_callModel.Encode(strm);
  9453.   m_endpointIdentifier.Encode(strm);
  9454.   if (HasOptionalField(e_destinationInfo))
  9455.     m_destinationInfo.Encode(strm);
  9456.   if (HasOptionalField(e_destCallSignalAddress))
  9457.     m_destCallSignalAddress.Encode(strm);
  9458.   if (HasOptionalField(e_destExtraCallInfo))
  9459.     m_destExtraCallInfo.Encode(strm);
  9460.   m_srcInfo.Encode(strm);
  9461.   if (HasOptionalField(e_srcCallSignalAddress))
  9462.     m_srcCallSignalAddress.Encode(strm);
  9463.   m_bandWidth.Encode(strm);
  9464.   m_callReferenceValue.Encode(strm);
  9465.   if (HasOptionalField(e_nonStandardData))
  9466.     m_nonStandardData.Encode(strm);
  9467.   if (HasOptionalField(e_callServices))
  9468.     m_callServices.Encode(strm);
  9469.   m_conferenceID.Encode(strm);
  9470.   m_activeMC.Encode(strm);
  9471.   m_answerCall.Encode(strm);
  9472.   KnownExtensionEncode(strm, e_canMapAlias, m_canMapAlias);
  9473.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  9474.   KnownExtensionEncode(strm, e_srcAlternatives, m_srcAlternatives);
  9475.   KnownExtensionEncode(strm, e_destAlternatives, m_destAlternatives);
  9476.   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
  9477.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  9478.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  9479.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  9480.   KnownExtensionEncode(strm, e_transportQOS, m_transportQOS);
  9481.   KnownExtensionEncode(strm, e_willSupplyUUIEs, m_willSupplyUUIEs);
  9482.   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
  9483.   KnownExtensionEncode(strm, e_gatewayDataRate, m_gatewayDataRate);
  9484.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  9485.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  9486.   KnownExtensionEncode(strm, e_desiredProtocols, m_desiredProtocols);
  9487.   KnownExtensionEncode(strm, e_desiredTunnelledProtocol, m_desiredTunnelledProtocol);
  9488.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  9489.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  9490.  
  9491.   UnknownExtensionsEncode(strm);
  9492. }
  9493.  
  9494.  
  9495. PObject * H225_AdmissionRequest::Clone() const
  9496. {
  9497. #ifndef PASN_LEANANDMEAN
  9498.   PAssert(IsClass(H225_AdmissionRequest::Class()), PInvalidCast);
  9499. #endif
  9500.   return new H225_AdmissionRequest(*this);
  9501. }
  9502.  
  9503.  
  9504. //
  9505. // BandwidthRequest
  9506. //
  9507.  
  9508. H225_BandwidthRequest::H225_BandwidthRequest(unsigned tag, PASN_Object::TagClass tagClass)
  9509.   : PASN_Sequence(tag, tagClass, 2, TRUE, 11)
  9510. {
  9511.   IncludeOptionalField(e_callIdentifier);
  9512.   IncludeOptionalField(e_answeredCall);
  9513. }
  9514.  
  9515.  
  9516. #ifndef PASN_NOPRINTON
  9517. void H225_BandwidthRequest::PrintOn(ostream & strm) const
  9518. {
  9519.   int indent = strm.precision() + 2;
  9520.   strm << "{\n";
  9521.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  9522.   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  9523.   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  9524.   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
  9525.   if (HasOptionalField(e_callType))
  9526.     strm << setw(indent+11) << "callType = " << setprecision(indent) << m_callType << '\n';
  9527.   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
  9528.   if (HasOptionalField(e_nonStandardData))
  9529.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  9530.   if (HasOptionalField(e_callIdentifier))
  9531.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  9532.   if (HasOptionalField(e_gatekeeperIdentifier))
  9533.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  9534.   if (HasOptionalField(e_tokens))
  9535.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  9536.   if (HasOptionalField(e_cryptoTokens))
  9537.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  9538.   if (HasOptionalField(e_integrityCheckValue))
  9539.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  9540.   if (HasOptionalField(e_answeredCall))
  9541.     strm << setw(indent+15) << "answeredCall = " << setprecision(indent) << m_answeredCall << '\n';
  9542.   if (HasOptionalField(e_callLinkage))
  9543.     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
  9544.   if (HasOptionalField(e_capacity))
  9545.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  9546.   if (HasOptionalField(e_usageInformation))
  9547.     strm << setw(indent+19) << "usageInformation = " << setprecision(indent) << m_usageInformation << '\n';
  9548.   if (HasOptionalField(e_bandwidthDetails))
  9549.     strm << setw(indent+19) << "bandwidthDetails = " << setprecision(indent) << m_bandwidthDetails << '\n';
  9550.   if (HasOptionalField(e_genericData))
  9551.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  9552.   strm << setw(indent-1) << "}";
  9553. }
  9554. #endif
  9555.  
  9556.  
  9557. PObject::Comparison H225_BandwidthRequest::Compare(const PObject & obj) const
  9558. {
  9559. #ifndef PASN_LEANANDMEAN
  9560.   PAssert(IsDescendant(H225_BandwidthRequest::Class()), PInvalidCast);
  9561. #endif
  9562.   const H225_BandwidthRequest & other = (const H225_BandwidthRequest &)obj;
  9563.  
  9564.   Comparison result;
  9565.  
  9566.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  9567.     return result;
  9568.   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
  9569.     return result;
  9570.   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
  9571.     return result;
  9572.   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
  9573.     return result;
  9574.   if ((result = m_callType.Compare(other.m_callType)) != EqualTo)
  9575.     return result;
  9576.   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
  9577.     return result;
  9578.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  9579.     return result;
  9580.  
  9581.   return PASN_Sequence::Compare(other);
  9582. }
  9583.  
  9584.  
  9585. PINDEX H225_BandwidthRequest::GetDataLength() const
  9586. {
  9587.   PINDEX length = 0;
  9588.   length += m_requestSeqNum.GetObjectLength();
  9589.   length += m_endpointIdentifier.GetObjectLength();
  9590.   length += m_conferenceID.GetObjectLength();
  9591.   length += m_callReferenceValue.GetObjectLength();
  9592.   if (HasOptionalField(e_callType))
  9593.     length += m_callType.GetObjectLength();
  9594.   length += m_bandWidth.GetObjectLength();
  9595.   if (HasOptionalField(e_nonStandardData))
  9596.     length += m_nonStandardData.GetObjectLength();
  9597.   return length;
  9598. }
  9599.  
  9600.  
  9601. BOOL H225_BandwidthRequest::Decode(PASN_Stream & strm)
  9602. {
  9603.   if (!PreambleDecode(strm))
  9604.     return FALSE;
  9605.  
  9606.   if (!m_requestSeqNum.Decode(strm))
  9607.     return FALSE;
  9608.   if (!m_endpointIdentifier.Decode(strm))
  9609.     return FALSE;
  9610.   if (!m_conferenceID.Decode(strm))
  9611.     return FALSE;
  9612.   if (!m_callReferenceValue.Decode(strm))
  9613.     return FALSE;
  9614.   if (HasOptionalField(e_callType) && !m_callType.Decode(strm))
  9615.     return FALSE;
  9616.   if (!m_bandWidth.Decode(strm))
  9617.     return FALSE;
  9618.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  9619.     return FALSE;
  9620.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  9621.     return FALSE;
  9622.   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
  9623.     return FALSE;
  9624.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  9625.     return FALSE;
  9626.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  9627.     return FALSE;
  9628.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  9629.     return FALSE;
  9630.   if (!KnownExtensionDecode(strm, e_answeredCall, m_answeredCall))
  9631.     return FALSE;
  9632.   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
  9633.     return FALSE;
  9634.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  9635.     return FALSE;
  9636.   if (!KnownExtensionDecode(strm, e_usageInformation, m_usageInformation))
  9637.     return FALSE;
  9638.   if (!KnownExtensionDecode(strm, e_bandwidthDetails, m_bandwidthDetails))
  9639.     return FALSE;
  9640.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  9641.     return FALSE;
  9642.  
  9643.   return UnknownExtensionsDecode(strm);
  9644. }
  9645.  
  9646.  
  9647. void H225_BandwidthRequest::Encode(PASN_Stream & strm) const
  9648. {
  9649.   PreambleEncode(strm);
  9650.  
  9651.   m_requestSeqNum.Encode(strm);
  9652.   m_endpointIdentifier.Encode(strm);
  9653.   m_conferenceID.Encode(strm);
  9654.   m_callReferenceValue.Encode(strm);
  9655.   if (HasOptionalField(e_callType))
  9656.     m_callType.Encode(strm);
  9657.   m_bandWidth.Encode(strm);
  9658.   if (HasOptionalField(e_nonStandardData))
  9659.     m_nonStandardData.Encode(strm);
  9660.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  9661.   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
  9662.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  9663.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  9664.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  9665.   KnownExtensionEncode(strm, e_answeredCall, m_answeredCall);
  9666.   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
  9667.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  9668.   KnownExtensionEncode(strm, e_usageInformation, m_usageInformation);
  9669.   KnownExtensionEncode(strm, e_bandwidthDetails, m_bandwidthDetails);
  9670.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  9671.  
  9672.   UnknownExtensionsEncode(strm);
  9673. }
  9674.  
  9675.  
  9676. PObject * H225_BandwidthRequest::Clone() const
  9677. {
  9678. #ifndef PASN_LEANANDMEAN
  9679.   PAssert(IsClass(H225_BandwidthRequest::Class()), PInvalidCast);
  9680. #endif
  9681.   return new H225_BandwidthRequest(*this);
  9682. }
  9683.  
  9684.  
  9685. //
  9686. // BandwidthConfirm
  9687. //
  9688.  
  9689. H225_BandwidthConfirm::H225_BandwidthConfirm(unsigned tag, PASN_Object::TagClass tagClass)
  9690.   : PASN_Sequence(tag, tagClass, 1, TRUE, 5)
  9691. {
  9692. }
  9693.  
  9694.  
  9695. #ifndef PASN_NOPRINTON
  9696. void H225_BandwidthConfirm::PrintOn(ostream & strm) const
  9697. {
  9698.   int indent = strm.precision() + 2;
  9699.   strm << "{\n";
  9700.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  9701.   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
  9702.   if (HasOptionalField(e_nonStandardData))
  9703.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  9704.   if (HasOptionalField(e_tokens))
  9705.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  9706.   if (HasOptionalField(e_cryptoTokens))
  9707.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  9708.   if (HasOptionalField(e_integrityCheckValue))
  9709.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  9710.   if (HasOptionalField(e_capacity))
  9711.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  9712.   if (HasOptionalField(e_genericData))
  9713.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  9714.   strm << setw(indent-1) << "}";
  9715. }
  9716. #endif
  9717.  
  9718.  
  9719. PObject::Comparison H225_BandwidthConfirm::Compare(const PObject & obj) const
  9720. {
  9721. #ifndef PASN_LEANANDMEAN
  9722.   PAssert(IsDescendant(H225_BandwidthConfirm::Class()), PInvalidCast);
  9723. #endif
  9724.   const H225_BandwidthConfirm & other = (const H225_BandwidthConfirm &)obj;
  9725.  
  9726.   Comparison result;
  9727.  
  9728.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  9729.     return result;
  9730.   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
  9731.     return result;
  9732.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  9733.     return result;
  9734.  
  9735.   return PASN_Sequence::Compare(other);
  9736. }
  9737.  
  9738.  
  9739. PINDEX H225_BandwidthConfirm::GetDataLength() const
  9740. {
  9741.   PINDEX length = 0;
  9742.   length += m_requestSeqNum.GetObjectLength();
  9743.   length += m_bandWidth.GetObjectLength();
  9744.   if (HasOptionalField(e_nonStandardData))
  9745.     length += m_nonStandardData.GetObjectLength();
  9746.   return length;
  9747. }
  9748.  
  9749.  
  9750. BOOL H225_BandwidthConfirm::Decode(PASN_Stream & strm)
  9751. {
  9752.   if (!PreambleDecode(strm))
  9753.     return FALSE;
  9754.  
  9755.   if (!m_requestSeqNum.Decode(strm))
  9756.     return FALSE;
  9757.   if (!m_bandWidth.Decode(strm))
  9758.     return FALSE;
  9759.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  9760.     return FALSE;
  9761.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  9762.     return FALSE;
  9763.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  9764.     return FALSE;
  9765.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  9766.     return FALSE;
  9767.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  9768.     return FALSE;
  9769.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  9770.     return FALSE;
  9771.  
  9772.   return UnknownExtensionsDecode(strm);
  9773. }
  9774.  
  9775.  
  9776. void H225_BandwidthConfirm::Encode(PASN_Stream & strm) const
  9777. {
  9778.   PreambleEncode(strm);
  9779.  
  9780.   m_requestSeqNum.Encode(strm);
  9781.   m_bandWidth.Encode(strm);
  9782.   if (HasOptionalField(e_nonStandardData))
  9783.     m_nonStandardData.Encode(strm);
  9784.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  9785.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  9786.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  9787.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  9788.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  9789.  
  9790.   UnknownExtensionsEncode(strm);
  9791. }
  9792.  
  9793.  
  9794. PObject * H225_BandwidthConfirm::Clone() const
  9795. {
  9796. #ifndef PASN_LEANANDMEAN
  9797.   PAssert(IsClass(H225_BandwidthConfirm::Class()), PInvalidCast);
  9798. #endif
  9799.   return new H225_BandwidthConfirm(*this);
  9800. }
  9801.  
  9802.  
  9803. //
  9804. // DisengageRequest
  9805. //
  9806.  
  9807. H225_DisengageRequest::H225_DisengageRequest(unsigned tag, PASN_Object::TagClass tagClass)
  9808.   : PASN_Sequence(tag, tagClass, 1, TRUE, 13)
  9809. {
  9810.   IncludeOptionalField(e_callIdentifier);
  9811.   IncludeOptionalField(e_answeredCall);
  9812. }
  9813.  
  9814.  
  9815. #ifndef PASN_NOPRINTON
  9816. void H225_DisengageRequest::PrintOn(ostream & strm) const
  9817. {
  9818.   int indent = strm.precision() + 2;
  9819.   strm << "{\n";
  9820.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  9821.   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  9822.   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  9823.   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
  9824.   strm << setw(indent+18) << "disengageReason = " << setprecision(indent) << m_disengageReason << '\n';
  9825.   if (HasOptionalField(e_nonStandardData))
  9826.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  9827.   if (HasOptionalField(e_callIdentifier))
  9828.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  9829.   if (HasOptionalField(e_gatekeeperIdentifier))
  9830.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  9831.   if (HasOptionalField(e_tokens))
  9832.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  9833.   if (HasOptionalField(e_cryptoTokens))
  9834.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  9835.   if (HasOptionalField(e_integrityCheckValue))
  9836.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  9837.   if (HasOptionalField(e_answeredCall))
  9838.     strm << setw(indent+15) << "answeredCall = " << setprecision(indent) << m_answeredCall << '\n';
  9839.   if (HasOptionalField(e_callLinkage))
  9840.     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
  9841.   if (HasOptionalField(e_capacity))
  9842.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  9843.   if (HasOptionalField(e_circuitInfo))
  9844.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  9845.   if (HasOptionalField(e_usageInformation))
  9846.     strm << setw(indent+19) << "usageInformation = " << setprecision(indent) << m_usageInformation << '\n';
  9847.   if (HasOptionalField(e_terminationCause))
  9848.     strm << setw(indent+19) << "terminationCause = " << setprecision(indent) << m_terminationCause << '\n';
  9849.   if (HasOptionalField(e_serviceControl))
  9850.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  9851.   if (HasOptionalField(e_genericData))
  9852.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  9853.   strm << setw(indent-1) << "}";
  9854. }
  9855. #endif
  9856.  
  9857.  
  9858. PObject::Comparison H225_DisengageRequest::Compare(const PObject & obj) const
  9859. {
  9860. #ifndef PASN_LEANANDMEAN
  9861.   PAssert(IsDescendant(H225_DisengageRequest::Class()), PInvalidCast);
  9862. #endif
  9863.   const H225_DisengageRequest & other = (const H225_DisengageRequest &)obj;
  9864.  
  9865.   Comparison result;
  9866.  
  9867.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  9868.     return result;
  9869.   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
  9870.     return result;
  9871.   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
  9872.     return result;
  9873.   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
  9874.     return result;
  9875.   if ((result = m_disengageReason.Compare(other.m_disengageReason)) != EqualTo)
  9876.     return result;
  9877.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  9878.     return result;
  9879.  
  9880.   return PASN_Sequence::Compare(other);
  9881. }
  9882.  
  9883.  
  9884. PINDEX H225_DisengageRequest::GetDataLength() const
  9885. {
  9886.   PINDEX length = 0;
  9887.   length += m_requestSeqNum.GetObjectLength();
  9888.   length += m_endpointIdentifier.GetObjectLength();
  9889.   length += m_conferenceID.GetObjectLength();
  9890.   length += m_callReferenceValue.GetObjectLength();
  9891.   length += m_disengageReason.GetObjectLength();
  9892.   if (HasOptionalField(e_nonStandardData))
  9893.     length += m_nonStandardData.GetObjectLength();
  9894.   return length;
  9895. }
  9896.  
  9897.  
  9898. BOOL H225_DisengageRequest::Decode(PASN_Stream & strm)
  9899. {
  9900.   if (!PreambleDecode(strm))
  9901.     return FALSE;
  9902.  
  9903.   if (!m_requestSeqNum.Decode(strm))
  9904.     return FALSE;
  9905.   if (!m_endpointIdentifier.Decode(strm))
  9906.     return FALSE;
  9907.   if (!m_conferenceID.Decode(strm))
  9908.     return FALSE;
  9909.   if (!m_callReferenceValue.Decode(strm))
  9910.     return FALSE;
  9911.   if (!m_disengageReason.Decode(strm))
  9912.     return FALSE;
  9913.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  9914.     return FALSE;
  9915.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  9916.     return FALSE;
  9917.   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
  9918.     return FALSE;
  9919.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  9920.     return FALSE;
  9921.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  9922.     return FALSE;
  9923.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  9924.     return FALSE;
  9925.   if (!KnownExtensionDecode(strm, e_answeredCall, m_answeredCall))
  9926.     return FALSE;
  9927.   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
  9928.     return FALSE;
  9929.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  9930.     return FALSE;
  9931.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  9932.     return FALSE;
  9933.   if (!KnownExtensionDecode(strm, e_usageInformation, m_usageInformation))
  9934.     return FALSE;
  9935.   if (!KnownExtensionDecode(strm, e_terminationCause, m_terminationCause))
  9936.     return FALSE;
  9937.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  9938.     return FALSE;
  9939.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  9940.     return FALSE;
  9941.  
  9942.   return UnknownExtensionsDecode(strm);
  9943. }
  9944.  
  9945.  
  9946. void H225_DisengageRequest::Encode(PASN_Stream & strm) const
  9947. {
  9948.   PreambleEncode(strm);
  9949.  
  9950.   m_requestSeqNum.Encode(strm);
  9951.   m_endpointIdentifier.Encode(strm);
  9952.   m_conferenceID.Encode(strm);
  9953.   m_callReferenceValue.Encode(strm);
  9954.   m_disengageReason.Encode(strm);
  9955.   if (HasOptionalField(e_nonStandardData))
  9956.     m_nonStandardData.Encode(strm);
  9957.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  9958.   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
  9959.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  9960.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  9961.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  9962.   KnownExtensionEncode(strm, e_answeredCall, m_answeredCall);
  9963.   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
  9964.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  9965.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  9966.   KnownExtensionEncode(strm, e_usageInformation, m_usageInformation);
  9967.   KnownExtensionEncode(strm, e_terminationCause, m_terminationCause);
  9968.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  9969.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  9970.  
  9971.   UnknownExtensionsEncode(strm);
  9972. }
  9973.  
  9974.  
  9975. PObject * H225_DisengageRequest::Clone() const
  9976. {
  9977. #ifndef PASN_LEANANDMEAN
  9978.   PAssert(IsClass(H225_DisengageRequest::Class()), PInvalidCast);
  9979. #endif
  9980.   return new H225_DisengageRequest(*this);
  9981. }
  9982.  
  9983.  
  9984. //
  9985. // DisengageConfirm
  9986. //
  9987.  
  9988. H225_DisengageConfirm::H225_DisengageConfirm(unsigned tag, PASN_Object::TagClass tagClass)
  9989.   : PASN_Sequence(tag, tagClass, 1, TRUE, 7)
  9990. {
  9991. }
  9992.  
  9993.  
  9994. #ifndef PASN_NOPRINTON
  9995. void H225_DisengageConfirm::PrintOn(ostream & strm) const
  9996. {
  9997.   int indent = strm.precision() + 2;
  9998.   strm << "{\n";
  9999.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  10000.   if (HasOptionalField(e_nonStandardData))
  10001.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  10002.   if (HasOptionalField(e_tokens))
  10003.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  10004.   if (HasOptionalField(e_cryptoTokens))
  10005.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  10006.   if (HasOptionalField(e_integrityCheckValue))
  10007.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  10008.   if (HasOptionalField(e_capacity))
  10009.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  10010.   if (HasOptionalField(e_circuitInfo))
  10011.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  10012.   if (HasOptionalField(e_usageInformation))
  10013.     strm << setw(indent+19) << "usageInformation = " << setprecision(indent) << m_usageInformation << '\n';
  10014.   if (HasOptionalField(e_genericData))
  10015.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  10016.   strm << setw(indent-1) << "}";
  10017. }
  10018. #endif
  10019.  
  10020.  
  10021. PObject::Comparison H225_DisengageConfirm::Compare(const PObject & obj) const
  10022. {
  10023. #ifndef PASN_LEANANDMEAN
  10024.   PAssert(IsDescendant(H225_DisengageConfirm::Class()), PInvalidCast);
  10025. #endif
  10026.   const H225_DisengageConfirm & other = (const H225_DisengageConfirm &)obj;
  10027.  
  10028.   Comparison result;
  10029.  
  10030.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  10031.     return result;
  10032.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  10033.     return result;
  10034.  
  10035.   return PASN_Sequence::Compare(other);
  10036. }
  10037.  
  10038.  
  10039. PINDEX H225_DisengageConfirm::GetDataLength() const
  10040. {
  10041.   PINDEX length = 0;
  10042.   length += m_requestSeqNum.GetObjectLength();
  10043.   if (HasOptionalField(e_nonStandardData))
  10044.     length += m_nonStandardData.GetObjectLength();
  10045.   return length;
  10046. }
  10047.  
  10048.  
  10049. BOOL H225_DisengageConfirm::Decode(PASN_Stream & strm)
  10050. {
  10051.   if (!PreambleDecode(strm))
  10052.     return FALSE;
  10053.  
  10054.   if (!m_requestSeqNum.Decode(strm))
  10055.     return FALSE;
  10056.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  10057.     return FALSE;
  10058.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  10059.     return FALSE;
  10060.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  10061.     return FALSE;
  10062.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  10063.     return FALSE;
  10064.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  10065.     return FALSE;
  10066.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  10067.     return FALSE;
  10068.   if (!KnownExtensionDecode(strm, e_usageInformation, m_usageInformation))
  10069.     return FALSE;
  10070.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  10071.     return FALSE;
  10072.  
  10073.   return UnknownExtensionsDecode(strm);
  10074. }
  10075.  
  10076.  
  10077. void H225_DisengageConfirm::Encode(PASN_Stream & strm) const
  10078. {
  10079.   PreambleEncode(strm);
  10080.  
  10081.   m_requestSeqNum.Encode(strm);
  10082.   if (HasOptionalField(e_nonStandardData))
  10083.     m_nonStandardData.Encode(strm);
  10084.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  10085.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  10086.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  10087.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  10088.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  10089.   KnownExtensionEncode(strm, e_usageInformation, m_usageInformation);
  10090.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  10091.  
  10092.   UnknownExtensionsEncode(strm);
  10093. }
  10094.  
  10095.  
  10096. PObject * H225_DisengageConfirm::Clone() const
  10097. {
  10098. #ifndef PASN_LEANANDMEAN
  10099.   PAssert(IsClass(H225_DisengageConfirm::Class()), PInvalidCast);
  10100. #endif
  10101.   return new H225_DisengageConfirm(*this);
  10102. }
  10103.  
  10104.  
  10105. //
  10106. // ResourcesAvailableIndicate
  10107. //
  10108.  
  10109. H225_ResourcesAvailableIndicate::H225_ResourcesAvailableIndicate(unsigned tag, PASN_Object::TagClass tagClass)
  10110.   : PASN_Sequence(tag, tagClass, 4, TRUE, 2)
  10111. {
  10112. }
  10113.  
  10114.  
  10115. #ifndef PASN_NOPRINTON
  10116. void H225_ResourcesAvailableIndicate::PrintOn(ostream & strm) const
  10117. {
  10118.   int indent = strm.precision() + 2;
  10119.   strm << "{\n";
  10120.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  10121.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  10122.   if (HasOptionalField(e_nonStandardData))
  10123.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  10124.   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  10125.   strm << setw(indent+12) << "protocols = " << setprecision(indent) << m_protocols << '\n';
  10126.   strm << setw(indent+23) << "almostOutOfResources = " << setprecision(indent) << m_almostOutOfResources << '\n';
  10127.   if (HasOptionalField(e_tokens))
  10128.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  10129.   if (HasOptionalField(e_cryptoTokens))
  10130.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  10131.   if (HasOptionalField(e_integrityCheckValue))
  10132.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  10133.   if (HasOptionalField(e_capacity))
  10134.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  10135.   if (HasOptionalField(e_genericData))
  10136.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  10137.   strm << setw(indent-1) << "}";
  10138. }
  10139. #endif
  10140.  
  10141.  
  10142. PObject::Comparison H225_ResourcesAvailableIndicate::Compare(const PObject & obj) const
  10143. {
  10144. #ifndef PASN_LEANANDMEAN
  10145.   PAssert(IsDescendant(H225_ResourcesAvailableIndicate::Class()), PInvalidCast);
  10146. #endif
  10147.   const H225_ResourcesAvailableIndicate & other = (const H225_ResourcesAvailableIndicate &)obj;
  10148.  
  10149.   Comparison result;
  10150.  
  10151.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  10152.     return result;
  10153.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  10154.     return result;
  10155.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  10156.     return result;
  10157.   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
  10158.     return result;
  10159.   if ((result = m_protocols.Compare(other.m_protocols)) != EqualTo)
  10160.     return result;
  10161.   if ((result = m_almostOutOfResources.Compare(other.m_almostOutOfResources)) != EqualTo)
  10162.     return result;
  10163.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  10164.     return result;
  10165.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  10166.     return result;
  10167.   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
  10168.     return result;
  10169.  
  10170.   return PASN_Sequence::Compare(other);
  10171. }
  10172.  
  10173.  
  10174. PINDEX H225_ResourcesAvailableIndicate::GetDataLength() const
  10175. {
  10176.   PINDEX length = 0;
  10177.   length += m_requestSeqNum.GetObjectLength();
  10178.   length += m_protocolIdentifier.GetObjectLength();
  10179.   if (HasOptionalField(e_nonStandardData))
  10180.     length += m_nonStandardData.GetObjectLength();
  10181.   length += m_endpointIdentifier.GetObjectLength();
  10182.   length += m_protocols.GetObjectLength();
  10183.   length += m_almostOutOfResources.GetObjectLength();
  10184.   if (HasOptionalField(e_tokens))
  10185.     length += m_tokens.GetObjectLength();
  10186.   if (HasOptionalField(e_cryptoTokens))
  10187.     length += m_cryptoTokens.GetObjectLength();
  10188.   if (HasOptionalField(e_integrityCheckValue))
  10189.     length += m_integrityCheckValue.GetObjectLength();
  10190.   return length;
  10191. }
  10192.  
  10193.  
  10194. BOOL H225_ResourcesAvailableIndicate::Decode(PASN_Stream & strm)
  10195. {
  10196.   if (!PreambleDecode(strm))
  10197.     return FALSE;
  10198.  
  10199.   if (!m_requestSeqNum.Decode(strm))
  10200.     return FALSE;
  10201.   if (!m_protocolIdentifier.Decode(strm))
  10202.     return FALSE;
  10203.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  10204.     return FALSE;
  10205.   if (!m_endpointIdentifier.Decode(strm))
  10206.     return FALSE;
  10207.   if (!m_protocols.Decode(strm))
  10208.     return FALSE;
  10209.   if (!m_almostOutOfResources.Decode(strm))
  10210.     return FALSE;
  10211.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  10212.     return FALSE;
  10213.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  10214.     return FALSE;
  10215.   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
  10216.     return FALSE;
  10217.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  10218.     return FALSE;
  10219.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  10220.     return FALSE;
  10221.  
  10222.   return UnknownExtensionsDecode(strm);
  10223. }
  10224.  
  10225.  
  10226. void H225_ResourcesAvailableIndicate::Encode(PASN_Stream & strm) const
  10227. {
  10228.   PreambleEncode(strm);
  10229.  
  10230.   m_requestSeqNum.Encode(strm);
  10231.   m_protocolIdentifier.Encode(strm);
  10232.   if (HasOptionalField(e_nonStandardData))
  10233.     m_nonStandardData.Encode(strm);
  10234.   m_endpointIdentifier.Encode(strm);
  10235.   m_protocols.Encode(strm);
  10236.   m_almostOutOfResources.Encode(strm);
  10237.   if (HasOptionalField(e_tokens))
  10238.     m_tokens.Encode(strm);
  10239.   if (HasOptionalField(e_cryptoTokens))
  10240.     m_cryptoTokens.Encode(strm);
  10241.   if (HasOptionalField(e_integrityCheckValue))
  10242.     m_integrityCheckValue.Encode(strm);
  10243.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  10244.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  10245.  
  10246.   UnknownExtensionsEncode(strm);
  10247. }
  10248.  
  10249.  
  10250. PObject * H225_ResourcesAvailableIndicate::Clone() const
  10251. {
  10252. #ifndef PASN_LEANANDMEAN
  10253.   PAssert(IsClass(H225_ResourcesAvailableIndicate::Class()), PInvalidCast);
  10254. #endif
  10255.   return new H225_ResourcesAvailableIndicate(*this);
  10256. }
  10257.  
  10258.  
  10259. //
  10260. // H323-UU-PDU
  10261. //
  10262.  
  10263. H225_H323_UU_PDU::H225_H323_UU_PDU(unsigned tag, PASN_Object::TagClass tagClass)
  10264.   : PASN_Sequence(tag, tagClass, 1, TRUE, 9)
  10265. {
  10266.   IncludeOptionalField(e_h245Tunneling);
  10267. }
  10268.  
  10269.  
  10270. #ifndef PASN_NOPRINTON
  10271. void H225_H323_UU_PDU::PrintOn(ostream & strm) const
  10272. {
  10273.   int indent = strm.precision() + 2;
  10274.   strm << "{\n";
  10275.   strm << setw(indent+20) << "h323_message_body = " << setprecision(indent) << m_h323_message_body << '\n';
  10276.   if (HasOptionalField(e_nonStandardData))
  10277.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  10278.   if (HasOptionalField(e_h4501SupplementaryService))
  10279.     strm << setw(indent+28) << "h4501SupplementaryService = " << setprecision(indent) << m_h4501SupplementaryService << '\n';
  10280.   if (HasOptionalField(e_h245Tunneling))
  10281.     strm << setw(indent+16) << "h245Tunneling = " << setprecision(indent) << m_h245Tunneling << '\n';
  10282.   if (HasOptionalField(e_h245Control))
  10283.     strm << setw(indent+14) << "h245Control = " << setprecision(indent) << m_h245Control << '\n';
  10284.   if (HasOptionalField(e_nonStandardControl))
  10285.     strm << setw(indent+21) << "nonStandardControl = " << setprecision(indent) << m_nonStandardControl << '\n';
  10286.   if (HasOptionalField(e_callLinkage))
  10287.     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
  10288.   if (HasOptionalField(e_tunnelledSignallingMessage))
  10289.     strm << setw(indent+29) << "tunnelledSignallingMessage = " << setprecision(indent) << m_tunnelledSignallingMessage << '\n';
  10290.   if (HasOptionalField(e_provisionalRespToH245Tunneling))
  10291.     strm << setw(indent+33) << "provisionalRespToH245Tunneling = " << setprecision(indent) << m_provisionalRespToH245Tunneling << '\n';
  10292.   if (HasOptionalField(e_stimulusControl))
  10293.     strm << setw(indent+18) << "stimulusControl = " << setprecision(indent) << m_stimulusControl << '\n';
  10294.   if (HasOptionalField(e_genericData))
  10295.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  10296.   strm << setw(indent-1) << "}";
  10297. }
  10298. #endif
  10299.  
  10300.  
  10301. PObject::Comparison H225_H323_UU_PDU::Compare(const PObject & obj) const
  10302. {
  10303. #ifndef PASN_LEANANDMEAN
  10304.   PAssert(IsDescendant(H225_H323_UU_PDU::Class()), PInvalidCast);
  10305. #endif
  10306.   const H225_H323_UU_PDU & other = (const H225_H323_UU_PDU &)obj;
  10307.  
  10308.   Comparison result;
  10309.  
  10310.   if ((result = m_h323_message_body.Compare(other.m_h323_message_body)) != EqualTo)
  10311.     return result;
  10312.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  10313.     return result;
  10314.  
  10315.   return PASN_Sequence::Compare(other);
  10316. }
  10317.  
  10318.  
  10319. PINDEX H225_H323_UU_PDU::GetDataLength() const
  10320. {
  10321.   PINDEX length = 0;
  10322.   length += m_h323_message_body.GetObjectLength();
  10323.   if (HasOptionalField(e_nonStandardData))
  10324.     length += m_nonStandardData.GetObjectLength();
  10325.   return length;
  10326. }
  10327.  
  10328.  
  10329. BOOL H225_H323_UU_PDU::Decode(PASN_Stream & strm)
  10330. {
  10331.   if (!PreambleDecode(strm))
  10332.     return FALSE;
  10333.  
  10334.   if (!m_h323_message_body.Decode(strm))
  10335.     return FALSE;
  10336.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  10337.     return FALSE;
  10338.   if (!KnownExtensionDecode(strm, e_h4501SupplementaryService, m_h4501SupplementaryService))
  10339.     return FALSE;
  10340.   if (!KnownExtensionDecode(strm, e_h245Tunneling, m_h245Tunneling))
  10341.     return FALSE;
  10342.   if (!KnownExtensionDecode(strm, e_h245Control, m_h245Control))
  10343.     return FALSE;
  10344.   if (!KnownExtensionDecode(strm, e_nonStandardControl, m_nonStandardControl))
  10345.     return FALSE;
  10346.   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
  10347.     return FALSE;
  10348.   if (!KnownExtensionDecode(strm, e_tunnelledSignallingMessage, m_tunnelledSignallingMessage))
  10349.     return FALSE;
  10350.   if (!KnownExtensionDecode(strm, e_provisionalRespToH245Tunneling, m_provisionalRespToH245Tunneling))
  10351.     return FALSE;
  10352.   if (!KnownExtensionDecode(strm, e_stimulusControl, m_stimulusControl))
  10353.     return FALSE;
  10354.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  10355.     return FALSE;
  10356.  
  10357.   return UnknownExtensionsDecode(strm);
  10358. }
  10359.  
  10360.  
  10361. void H225_H323_UU_PDU::Encode(PASN_Stream & strm) const
  10362. {
  10363.   PreambleEncode(strm);
  10364.  
  10365.   m_h323_message_body.Encode(strm);
  10366.   if (HasOptionalField(e_nonStandardData))
  10367.     m_nonStandardData.Encode(strm);
  10368.   KnownExtensionEncode(strm, e_h4501SupplementaryService, m_h4501SupplementaryService);
  10369.   KnownExtensionEncode(strm, e_h245Tunneling, m_h245Tunneling);
  10370.   KnownExtensionEncode(strm, e_h245Control, m_h245Control);
  10371.   KnownExtensionEncode(strm, e_nonStandardControl, m_nonStandardControl);
  10372.   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
  10373.   KnownExtensionEncode(strm, e_tunnelledSignallingMessage, m_tunnelledSignallingMessage);
  10374.   KnownExtensionEncode(strm, e_provisionalRespToH245Tunneling, m_provisionalRespToH245Tunneling);
  10375.   KnownExtensionEncode(strm, e_stimulusControl, m_stimulusControl);
  10376.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  10377.  
  10378.   UnknownExtensionsEncode(strm);
  10379. }
  10380.  
  10381.  
  10382. PObject * H225_H323_UU_PDU::Clone() const
  10383. {
  10384. #ifndef PASN_LEANANDMEAN
  10385.   PAssert(IsClass(H225_H323_UU_PDU::Class()), PInvalidCast);
  10386. #endif
  10387.   return new H225_H323_UU_PDU(*this);
  10388. }
  10389.  
  10390.  
  10391. //
  10392. // ReleaseComplete-UUIE
  10393. //
  10394.  
  10395. H225_ReleaseComplete_UUIE::H225_ReleaseComplete_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  10396.   : PASN_Sequence(tag, tagClass, 1, TRUE, 9)
  10397. {
  10398.   IncludeOptionalField(e_callIdentifier);
  10399. }
  10400.  
  10401.  
  10402. #ifndef PASN_NOPRINTON
  10403. void H225_ReleaseComplete_UUIE::PrintOn(ostream & strm) const
  10404. {
  10405.   int indent = strm.precision() + 2;
  10406.   strm << "{\n";
  10407.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  10408.   if (HasOptionalField(e_reason))
  10409.     strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  10410.   if (HasOptionalField(e_callIdentifier))
  10411.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  10412.   if (HasOptionalField(e_tokens))
  10413.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  10414.   if (HasOptionalField(e_cryptoTokens))
  10415.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  10416.   if (HasOptionalField(e_busyAddress))
  10417.     strm << setw(indent+14) << "busyAddress = " << setprecision(indent) << m_busyAddress << '\n';
  10418.   if (HasOptionalField(e_presentationIndicator))
  10419.     strm << setw(indent+24) << "presentationIndicator = " << setprecision(indent) << m_presentationIndicator << '\n';
  10420.   if (HasOptionalField(e_screeningIndicator))
  10421.     strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
  10422.   if (HasOptionalField(e_capacity))
  10423.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  10424.   if (HasOptionalField(e_serviceControl))
  10425.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  10426.   if (HasOptionalField(e_featureSet))
  10427.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  10428.   strm << setw(indent-1) << "}";
  10429. }
  10430. #endif
  10431.  
  10432.  
  10433. PObject::Comparison H225_ReleaseComplete_UUIE::Compare(const PObject & obj) const
  10434. {
  10435. #ifndef PASN_LEANANDMEAN
  10436.   PAssert(IsDescendant(H225_ReleaseComplete_UUIE::Class()), PInvalidCast);
  10437. #endif
  10438.   const H225_ReleaseComplete_UUIE & other = (const H225_ReleaseComplete_UUIE &)obj;
  10439.  
  10440.   Comparison result;
  10441.  
  10442.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  10443.     return result;
  10444.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  10445.     return result;
  10446.  
  10447.   return PASN_Sequence::Compare(other);
  10448. }
  10449.  
  10450.  
  10451. PINDEX H225_ReleaseComplete_UUIE::GetDataLength() const
  10452. {
  10453.   PINDEX length = 0;
  10454.   length += m_protocolIdentifier.GetObjectLength();
  10455.   if (HasOptionalField(e_reason))
  10456.     length += m_reason.GetObjectLength();
  10457.   return length;
  10458. }
  10459.  
  10460.  
  10461. BOOL H225_ReleaseComplete_UUIE::Decode(PASN_Stream & strm)
  10462. {
  10463.   if (!PreambleDecode(strm))
  10464.     return FALSE;
  10465.  
  10466.   if (!m_protocolIdentifier.Decode(strm))
  10467.     return FALSE;
  10468.   if (HasOptionalField(e_reason) && !m_reason.Decode(strm))
  10469.     return FALSE;
  10470.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  10471.     return FALSE;
  10472.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  10473.     return FALSE;
  10474.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  10475.     return FALSE;
  10476.   if (!KnownExtensionDecode(strm, e_busyAddress, m_busyAddress))
  10477.     return FALSE;
  10478.   if (!KnownExtensionDecode(strm, e_presentationIndicator, m_presentationIndicator))
  10479.     return FALSE;
  10480.   if (!KnownExtensionDecode(strm, e_screeningIndicator, m_screeningIndicator))
  10481.     return FALSE;
  10482.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  10483.     return FALSE;
  10484.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  10485.     return FALSE;
  10486.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  10487.     return FALSE;
  10488.  
  10489.   return UnknownExtensionsDecode(strm);
  10490. }
  10491.  
  10492.  
  10493. void H225_ReleaseComplete_UUIE::Encode(PASN_Stream & strm) const
  10494. {
  10495.   PreambleEncode(strm);
  10496.  
  10497.   m_protocolIdentifier.Encode(strm);
  10498.   if (HasOptionalField(e_reason))
  10499.     m_reason.Encode(strm);
  10500.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  10501.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  10502.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  10503.   KnownExtensionEncode(strm, e_busyAddress, m_busyAddress);
  10504.   KnownExtensionEncode(strm, e_presentationIndicator, m_presentationIndicator);
  10505.   KnownExtensionEncode(strm, e_screeningIndicator, m_screeningIndicator);
  10506.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  10507.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  10508.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  10509.  
  10510.   UnknownExtensionsEncode(strm);
  10511. }
  10512.  
  10513.  
  10514. PObject * H225_ReleaseComplete_UUIE::Clone() const
  10515. {
  10516. #ifndef PASN_LEANANDMEAN
  10517.   PAssert(IsClass(H225_ReleaseComplete_UUIE::Class()), PInvalidCast);
  10518. #endif
  10519.   return new H225_ReleaseComplete_UUIE(*this);
  10520. }
  10521.  
  10522.  
  10523. //
  10524. // EndpointType
  10525. //
  10526.  
  10527. H225_EndpointType::H225_EndpointType(unsigned tag, PASN_Object::TagClass tagClass)
  10528.   : PASN_Sequence(tag, tagClass, 6, TRUE, 2)
  10529. {
  10530.   m_set.SetConstraints(PASN_Object::FixedConstraint, 32);
  10531. }
  10532.  
  10533.  
  10534. #ifndef PASN_NOPRINTON
  10535. void H225_EndpointType::PrintOn(ostream & strm) const
  10536. {
  10537.   int indent = strm.precision() + 2;
  10538.   strm << "{\n";
  10539.   if (HasOptionalField(e_nonStandardData))
  10540.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  10541.   if (HasOptionalField(e_vendor))
  10542.     strm << setw(indent+9) << "vendor = " << setprecision(indent) << m_vendor << '\n';
  10543.   if (HasOptionalField(e_gatekeeper))
  10544.     strm << setw(indent+13) << "gatekeeper = " << setprecision(indent) << m_gatekeeper << '\n';
  10545.   if (HasOptionalField(e_gateway))
  10546.     strm << setw(indent+10) << "gateway = " << setprecision(indent) << m_gateway << '\n';
  10547.   if (HasOptionalField(e_mcu))
  10548.     strm << setw(indent+6) << "mcu = " << setprecision(indent) << m_mcu << '\n';
  10549.   if (HasOptionalField(e_terminal))
  10550.     strm << setw(indent+11) << "terminal = " << setprecision(indent) << m_terminal << '\n';
  10551.   strm << setw(indent+5) << "mc = " << setprecision(indent) << m_mc << '\n';
  10552.   strm << setw(indent+16) << "undefinedNode = " << setprecision(indent) << m_undefinedNode << '\n';
  10553.   if (HasOptionalField(e_set))
  10554.     strm << setw(indent+6) << "set = " << setprecision(indent) << m_set << '\n';
  10555.   if (HasOptionalField(e_supportedTunnelledProtocols))
  10556.     strm << setw(indent+30) << "supportedTunnelledProtocols = " << setprecision(indent) << m_supportedTunnelledProtocols << '\n';
  10557.   strm << setw(indent-1) << "}";
  10558. }
  10559. #endif
  10560.  
  10561.  
  10562. PObject::Comparison H225_EndpointType::Compare(const PObject & obj) const
  10563. {
  10564. #ifndef PASN_LEANANDMEAN
  10565.   PAssert(IsDescendant(H225_EndpointType::Class()), PInvalidCast);
  10566. #endif
  10567.   const H225_EndpointType & other = (const H225_EndpointType &)obj;
  10568.  
  10569.   Comparison result;
  10570.  
  10571.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  10572.     return result;
  10573.   if ((result = m_vendor.Compare(other.m_vendor)) != EqualTo)
  10574.     return result;
  10575.   if ((result = m_gatekeeper.Compare(other.m_gatekeeper)) != EqualTo)
  10576.     return result;
  10577.   if ((result = m_gateway.Compare(other.m_gateway)) != EqualTo)
  10578.     return result;
  10579.   if ((result = m_mcu.Compare(other.m_mcu)) != EqualTo)
  10580.     return result;
  10581.   if ((result = m_terminal.Compare(other.m_terminal)) != EqualTo)
  10582.     return result;
  10583.   if ((result = m_mc.Compare(other.m_mc)) != EqualTo)
  10584.     return result;
  10585.   if ((result = m_undefinedNode.Compare(other.m_undefinedNode)) != EqualTo)
  10586.     return result;
  10587.  
  10588.   return PASN_Sequence::Compare(other);
  10589. }
  10590.  
  10591.  
  10592. PINDEX H225_EndpointType::GetDataLength() const
  10593. {
  10594.   PINDEX length = 0;
  10595.   if (HasOptionalField(e_nonStandardData))
  10596.     length += m_nonStandardData.GetObjectLength();
  10597.   if (HasOptionalField(e_vendor))
  10598.     length += m_vendor.GetObjectLength();
  10599.   if (HasOptionalField(e_gatekeeper))
  10600.     length += m_gatekeeper.GetObjectLength();
  10601.   if (HasOptionalField(e_gateway))
  10602.     length += m_gateway.GetObjectLength();
  10603.   if (HasOptionalField(e_mcu))
  10604.     length += m_mcu.GetObjectLength();
  10605.   if (HasOptionalField(e_terminal))
  10606.     length += m_terminal.GetObjectLength();
  10607.   length += m_mc.GetObjectLength();
  10608.   length += m_undefinedNode.GetObjectLength();
  10609.   return length;
  10610. }
  10611.  
  10612.  
  10613. BOOL H225_EndpointType::Decode(PASN_Stream & strm)
  10614. {
  10615.   if (!PreambleDecode(strm))
  10616.     return FALSE;
  10617.  
  10618.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  10619.     return FALSE;
  10620.   if (HasOptionalField(e_vendor) && !m_vendor.Decode(strm))
  10621.     return FALSE;
  10622.   if (HasOptionalField(e_gatekeeper) && !m_gatekeeper.Decode(strm))
  10623.     return FALSE;
  10624.   if (HasOptionalField(e_gateway) && !m_gateway.Decode(strm))
  10625.     return FALSE;
  10626.   if (HasOptionalField(e_mcu) && !m_mcu.Decode(strm))
  10627.     return FALSE;
  10628.   if (HasOptionalField(e_terminal) && !m_terminal.Decode(strm))
  10629.     return FALSE;
  10630.   if (!m_mc.Decode(strm))
  10631.     return FALSE;
  10632.   if (!m_undefinedNode.Decode(strm))
  10633.     return FALSE;
  10634.   if (!KnownExtensionDecode(strm, e_set, m_set))
  10635.     return FALSE;
  10636.   if (!KnownExtensionDecode(strm, e_supportedTunnelledProtocols, m_supportedTunnelledProtocols))
  10637.     return FALSE;
  10638.  
  10639.   return UnknownExtensionsDecode(strm);
  10640. }
  10641.  
  10642.  
  10643. void H225_EndpointType::Encode(PASN_Stream & strm) const
  10644. {
  10645.   PreambleEncode(strm);
  10646.  
  10647.   if (HasOptionalField(e_nonStandardData))
  10648.     m_nonStandardData.Encode(strm);
  10649.   if (HasOptionalField(e_vendor))
  10650.     m_vendor.Encode(strm);
  10651.   if (HasOptionalField(e_gatekeeper))
  10652.     m_gatekeeper.Encode(strm);
  10653.   if (HasOptionalField(e_gateway))
  10654.     m_gateway.Encode(strm);
  10655.   if (HasOptionalField(e_mcu))
  10656.     m_mcu.Encode(strm);
  10657.   if (HasOptionalField(e_terminal))
  10658.     m_terminal.Encode(strm);
  10659.   m_mc.Encode(strm);
  10660.   m_undefinedNode.Encode(strm);
  10661.   KnownExtensionEncode(strm, e_set, m_set);
  10662.   KnownExtensionEncode(strm, e_supportedTunnelledProtocols, m_supportedTunnelledProtocols);
  10663.  
  10664.   UnknownExtensionsEncode(strm);
  10665. }
  10666.  
  10667.  
  10668. PObject * H225_EndpointType::Clone() const
  10669. {
  10670. #ifndef PASN_LEANANDMEAN
  10671.   PAssert(IsClass(H225_EndpointType::Class()), PInvalidCast);
  10672. #endif
  10673.   return new H225_EndpointType(*this);
  10674. }
  10675.  
  10676.  
  10677. //
  10678. // Endpoint
  10679. //
  10680.  
  10681. H225_Endpoint::H225_Endpoint(unsigned tag, PASN_Object::TagClass tagClass)
  10682.   : PASN_Sequence(tag, tagClass, 10, TRUE, 1)
  10683. {
  10684.   m_priority.SetConstraints(PASN_Object::FixedConstraint, 0, 127);
  10685. }
  10686.  
  10687.  
  10688. #ifndef PASN_NOPRINTON
  10689. void H225_Endpoint::PrintOn(ostream & strm) const
  10690. {
  10691.   int indent = strm.precision() + 2;
  10692.   strm << "{\n";
  10693.   if (HasOptionalField(e_nonStandardData))
  10694.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  10695.   if (HasOptionalField(e_aliasAddress))
  10696.     strm << setw(indent+15) << "aliasAddress = " << setprecision(indent) << m_aliasAddress << '\n';
  10697.   if (HasOptionalField(e_callSignalAddress))
  10698.     strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
  10699.   if (HasOptionalField(e_rasAddress))
  10700.     strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
  10701.   if (HasOptionalField(e_endpointType))
  10702.     strm << setw(indent+15) << "endpointType = " << setprecision(indent) << m_endpointType << '\n';
  10703.   if (HasOptionalField(e_tokens))
  10704.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  10705.   if (HasOptionalField(e_cryptoTokens))
  10706.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  10707.   if (HasOptionalField(e_priority))
  10708.     strm << setw(indent+11) << "priority = " << setprecision(indent) << m_priority << '\n';
  10709.   if (HasOptionalField(e_remoteExtensionAddress))
  10710.     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
  10711.   if (HasOptionalField(e_destExtraCallInfo))
  10712.     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
  10713.   if (HasOptionalField(e_alternateTransportAddresses))
  10714.     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
  10715.   strm << setw(indent-1) << "}";
  10716. }
  10717. #endif
  10718.  
  10719.  
  10720. PObject::Comparison H225_Endpoint::Compare(const PObject & obj) const
  10721. {
  10722. #ifndef PASN_LEANANDMEAN
  10723.   PAssert(IsDescendant(H225_Endpoint::Class()), PInvalidCast);
  10724. #endif
  10725.   const H225_Endpoint & other = (const H225_Endpoint &)obj;
  10726.  
  10727.   Comparison result;
  10728.  
  10729.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  10730.     return result;
  10731.   if ((result = m_aliasAddress.Compare(other.m_aliasAddress)) != EqualTo)
  10732.     return result;
  10733.   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
  10734.     return result;
  10735.   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
  10736.     return result;
  10737.   if ((result = m_endpointType.Compare(other.m_endpointType)) != EqualTo)
  10738.     return result;
  10739.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  10740.     return result;
  10741.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  10742.     return result;
  10743.   if ((result = m_priority.Compare(other.m_priority)) != EqualTo)
  10744.     return result;
  10745.   if ((result = m_remoteExtensionAddress.Compare(other.m_remoteExtensionAddress)) != EqualTo)
  10746.     return result;
  10747.   if ((result = m_destExtraCallInfo.Compare(other.m_destExtraCallInfo)) != EqualTo)
  10748.     return result;
  10749.  
  10750.   return PASN_Sequence::Compare(other);
  10751. }
  10752.  
  10753.  
  10754. PINDEX H225_Endpoint::GetDataLength() const
  10755. {
  10756.   PINDEX length = 0;
  10757.   if (HasOptionalField(e_nonStandardData))
  10758.     length += m_nonStandardData.GetObjectLength();
  10759.   if (HasOptionalField(e_aliasAddress))
  10760.     length += m_aliasAddress.GetObjectLength();
  10761.   if (HasOptionalField(e_callSignalAddress))
  10762.     length += m_callSignalAddress.GetObjectLength();
  10763.   if (HasOptionalField(e_rasAddress))
  10764.     length += m_rasAddress.GetObjectLength();
  10765.   if (HasOptionalField(e_endpointType))
  10766.     length += m_endpointType.GetObjectLength();
  10767.   if (HasOptionalField(e_tokens))
  10768.     length += m_tokens.GetObjectLength();
  10769.   if (HasOptionalField(e_cryptoTokens))
  10770.     length += m_cryptoTokens.GetObjectLength();
  10771.   if (HasOptionalField(e_priority))
  10772.     length += m_priority.GetObjectLength();
  10773.   if (HasOptionalField(e_remoteExtensionAddress))
  10774.     length += m_remoteExtensionAddress.GetObjectLength();
  10775.   if (HasOptionalField(e_destExtraCallInfo))
  10776.     length += m_destExtraCallInfo.GetObjectLength();
  10777.   return length;
  10778. }
  10779.  
  10780.  
  10781. BOOL H225_Endpoint::Decode(PASN_Stream & strm)
  10782. {
  10783.   if (!PreambleDecode(strm))
  10784.     return FALSE;
  10785.  
  10786.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  10787.     return FALSE;
  10788.   if (HasOptionalField(e_aliasAddress) && !m_aliasAddress.Decode(strm))
  10789.     return FALSE;
  10790.   if (HasOptionalField(e_callSignalAddress) && !m_callSignalAddress.Decode(strm))
  10791.     return FALSE;
  10792.   if (HasOptionalField(e_rasAddress) && !m_rasAddress.Decode(strm))
  10793.     return FALSE;
  10794.   if (HasOptionalField(e_endpointType) && !m_endpointType.Decode(strm))
  10795.     return FALSE;
  10796.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  10797.     return FALSE;
  10798.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  10799.     return FALSE;
  10800.   if (HasOptionalField(e_priority) && !m_priority.Decode(strm))
  10801.     return FALSE;
  10802.   if (HasOptionalField(e_remoteExtensionAddress) && !m_remoteExtensionAddress.Decode(strm))
  10803.     return FALSE;
  10804.   if (HasOptionalField(e_destExtraCallInfo) && !m_destExtraCallInfo.Decode(strm))
  10805.     return FALSE;
  10806.   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
  10807.     return FALSE;
  10808.  
  10809.   return UnknownExtensionsDecode(strm);
  10810. }
  10811.  
  10812.  
  10813. void H225_Endpoint::Encode(PASN_Stream & strm) const
  10814. {
  10815.   PreambleEncode(strm);
  10816.  
  10817.   if (HasOptionalField(e_nonStandardData))
  10818.     m_nonStandardData.Encode(strm);
  10819.   if (HasOptionalField(e_aliasAddress))
  10820.     m_aliasAddress.Encode(strm);
  10821.   if (HasOptionalField(e_callSignalAddress))
  10822.     m_callSignalAddress.Encode(strm);
  10823.   if (HasOptionalField(e_rasAddress))
  10824.     m_rasAddress.Encode(strm);
  10825.   if (HasOptionalField(e_endpointType))
  10826.     m_endpointType.Encode(strm);
  10827.   if (HasOptionalField(e_tokens))
  10828.     m_tokens.Encode(strm);
  10829.   if (HasOptionalField(e_cryptoTokens))
  10830.     m_cryptoTokens.Encode(strm);
  10831.   if (HasOptionalField(e_priority))
  10832.     m_priority.Encode(strm);
  10833.   if (HasOptionalField(e_remoteExtensionAddress))
  10834.     m_remoteExtensionAddress.Encode(strm);
  10835.   if (HasOptionalField(e_destExtraCallInfo))
  10836.     m_destExtraCallInfo.Encode(strm);
  10837.   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
  10838.  
  10839.   UnknownExtensionsEncode(strm);
  10840. }
  10841.  
  10842.  
  10843. PObject * H225_Endpoint::Clone() const
  10844. {
  10845. #ifndef PASN_LEANANDMEAN
  10846.   PAssert(IsClass(H225_Endpoint::Class()), PInvalidCast);
  10847. #endif
  10848.   return new H225_Endpoint(*this);
  10849. }
  10850.  
  10851.  
  10852. //
  10853. // GatekeeperRequest
  10854. //
  10855.  
  10856. H225_GatekeeperRequest::H225_GatekeeperRequest(unsigned tag, PASN_Object::TagClass tagClass)
  10857.   : PASN_Sequence(tag, tagClass, 4, TRUE, 10)
  10858. {
  10859. }
  10860.  
  10861.  
  10862. #ifndef PASN_NOPRINTON
  10863. void H225_GatekeeperRequest::PrintOn(ostream & strm) const
  10864. {
  10865.   int indent = strm.precision() + 2;
  10866.   strm << "{\n";
  10867.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  10868.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  10869.   if (HasOptionalField(e_nonStandardData))
  10870.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  10871.   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
  10872.   strm << setw(indent+15) << "endpointType = " << setprecision(indent) << m_endpointType << '\n';
  10873.   if (HasOptionalField(e_gatekeeperIdentifier))
  10874.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  10875.   if (HasOptionalField(e_callServices))
  10876.     strm << setw(indent+15) << "callServices = " << setprecision(indent) << m_callServices << '\n';
  10877.   if (HasOptionalField(e_endpointAlias))
  10878.     strm << setw(indent+16) << "endpointAlias = " << setprecision(indent) << m_endpointAlias << '\n';
  10879.   if (HasOptionalField(e_alternateEndpoints))
  10880.     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
  10881.   if (HasOptionalField(e_tokens))
  10882.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  10883.   if (HasOptionalField(e_cryptoTokens))
  10884.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  10885.   if (HasOptionalField(e_authenticationCapability))
  10886.     strm << setw(indent+27) << "authenticationCapability = " << setprecision(indent) << m_authenticationCapability << '\n';
  10887.   if (HasOptionalField(e_algorithmOIDs))
  10888.     strm << setw(indent+16) << "algorithmOIDs = " << setprecision(indent) << m_algorithmOIDs << '\n';
  10889.   if (HasOptionalField(e_integrity))
  10890.     strm << setw(indent+12) << "integrity = " << setprecision(indent) << m_integrity << '\n';
  10891.   if (HasOptionalField(e_integrityCheckValue))
  10892.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  10893.   if (HasOptionalField(e_supportsAltGK))
  10894.     strm << setw(indent+16) << "supportsAltGK = " << setprecision(indent) << m_supportsAltGK << '\n';
  10895.   if (HasOptionalField(e_featureSet))
  10896.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  10897.   if (HasOptionalField(e_genericData))
  10898.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  10899.   strm << setw(indent-1) << "}";
  10900. }
  10901. #endif
  10902.  
  10903.  
  10904. PObject::Comparison H225_GatekeeperRequest::Compare(const PObject & obj) const
  10905. {
  10906. #ifndef PASN_LEANANDMEAN
  10907.   PAssert(IsDescendant(H225_GatekeeperRequest::Class()), PInvalidCast);
  10908. #endif
  10909.   const H225_GatekeeperRequest & other = (const H225_GatekeeperRequest &)obj;
  10910.  
  10911.   Comparison result;
  10912.  
  10913.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  10914.     return result;
  10915.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  10916.     return result;
  10917.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  10918.     return result;
  10919.   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
  10920.     return result;
  10921.   if ((result = m_endpointType.Compare(other.m_endpointType)) != EqualTo)
  10922.     return result;
  10923.   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
  10924.     return result;
  10925.   if ((result = m_callServices.Compare(other.m_callServices)) != EqualTo)
  10926.     return result;
  10927.   if ((result = m_endpointAlias.Compare(other.m_endpointAlias)) != EqualTo)
  10928.     return result;
  10929.  
  10930.   return PASN_Sequence::Compare(other);
  10931. }
  10932.  
  10933.  
  10934. PINDEX H225_GatekeeperRequest::GetDataLength() const
  10935. {
  10936.   PINDEX length = 0;
  10937.   length += m_requestSeqNum.GetObjectLength();
  10938.   length += m_protocolIdentifier.GetObjectLength();
  10939.   if (HasOptionalField(e_nonStandardData))
  10940.     length += m_nonStandardData.GetObjectLength();
  10941.   length += m_rasAddress.GetObjectLength();
  10942.   length += m_endpointType.GetObjectLength();
  10943.   if (HasOptionalField(e_gatekeeperIdentifier))
  10944.     length += m_gatekeeperIdentifier.GetObjectLength();
  10945.   if (HasOptionalField(e_callServices))
  10946.     length += m_callServices.GetObjectLength();
  10947.   if (HasOptionalField(e_endpointAlias))
  10948.     length += m_endpointAlias.GetObjectLength();
  10949.   return length;
  10950. }
  10951.  
  10952.  
  10953. BOOL H225_GatekeeperRequest::Decode(PASN_Stream & strm)
  10954. {
  10955.   if (!PreambleDecode(strm))
  10956.     return FALSE;
  10957.  
  10958.   if (!m_requestSeqNum.Decode(strm))
  10959.     return FALSE;
  10960.   if (!m_protocolIdentifier.Decode(strm))
  10961.     return FALSE;
  10962.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  10963.     return FALSE;
  10964.   if (!m_rasAddress.Decode(strm))
  10965.     return FALSE;
  10966.   if (!m_endpointType.Decode(strm))
  10967.     return FALSE;
  10968.   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
  10969.     return FALSE;
  10970.   if (HasOptionalField(e_callServices) && !m_callServices.Decode(strm))
  10971.     return FALSE;
  10972.   if (HasOptionalField(e_endpointAlias) && !m_endpointAlias.Decode(strm))
  10973.     return FALSE;
  10974.   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
  10975.     return FALSE;
  10976.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  10977.     return FALSE;
  10978.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  10979.     return FALSE;
  10980.   if (!KnownExtensionDecode(strm, e_authenticationCapability, m_authenticationCapability))
  10981.     return FALSE;
  10982.   if (!KnownExtensionDecode(strm, e_algorithmOIDs, m_algorithmOIDs))
  10983.     return FALSE;
  10984.   if (!KnownExtensionDecode(strm, e_integrity, m_integrity))
  10985.     return FALSE;
  10986.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  10987.     return FALSE;
  10988.   if (!KnownExtensionDecode(strm, e_supportsAltGK, m_supportsAltGK))
  10989.     return FALSE;
  10990.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  10991.     return FALSE;
  10992.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  10993.     return FALSE;
  10994.  
  10995.   return UnknownExtensionsDecode(strm);
  10996. }
  10997.  
  10998.  
  10999. void H225_GatekeeperRequest::Encode(PASN_Stream & strm) const
  11000. {
  11001.   PreambleEncode(strm);
  11002.  
  11003.   m_requestSeqNum.Encode(strm);
  11004.   m_protocolIdentifier.Encode(strm);
  11005.   if (HasOptionalField(e_nonStandardData))
  11006.     m_nonStandardData.Encode(strm);
  11007.   m_rasAddress.Encode(strm);
  11008.   m_endpointType.Encode(strm);
  11009.   if (HasOptionalField(e_gatekeeperIdentifier))
  11010.     m_gatekeeperIdentifier.Encode(strm);
  11011.   if (HasOptionalField(e_callServices))
  11012.     m_callServices.Encode(strm);
  11013.   if (HasOptionalField(e_endpointAlias))
  11014.     m_endpointAlias.Encode(strm);
  11015.   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
  11016.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  11017.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  11018.   KnownExtensionEncode(strm, e_authenticationCapability, m_authenticationCapability);
  11019.   KnownExtensionEncode(strm, e_algorithmOIDs, m_algorithmOIDs);
  11020.   KnownExtensionEncode(strm, e_integrity, m_integrity);
  11021.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  11022.   KnownExtensionEncode(strm, e_supportsAltGK, m_supportsAltGK);
  11023.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  11024.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  11025.  
  11026.   UnknownExtensionsEncode(strm);
  11027. }
  11028.  
  11029.  
  11030. PObject * H225_GatekeeperRequest::Clone() const
  11031. {
  11032. #ifndef PASN_LEANANDMEAN
  11033.   PAssert(IsClass(H225_GatekeeperRequest::Class()), PInvalidCast);
  11034. #endif
  11035.   return new H225_GatekeeperRequest(*this);
  11036. }
  11037.  
  11038.  
  11039. //
  11040. // RegistrationRequest
  11041. //
  11042.  
  11043. H225_RegistrationRequest::H225_RegistrationRequest(unsigned tag, PASN_Object::TagClass tagClass)
  11044.   : PASN_Sequence(tag, tagClass, 3, TRUE, 21)
  11045. {
  11046.   IncludeOptionalField(e_keepAlive);
  11047.   IncludeOptionalField(e_willSupplyUUIEs);
  11048.   IncludeOptionalField(e_maintainConnection);
  11049. }
  11050.  
  11051.  
  11052. #ifndef PASN_NOPRINTON
  11053. void H225_RegistrationRequest::PrintOn(ostream & strm) const
  11054. {
  11055.   int indent = strm.precision() + 2;
  11056.   strm << "{\n";
  11057.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  11058.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  11059.   if (HasOptionalField(e_nonStandardData))
  11060.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  11061.   strm << setw(indent+20) << "discoveryComplete = " << setprecision(indent) << m_discoveryComplete << '\n';
  11062.   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
  11063.   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
  11064.   strm << setw(indent+15) << "terminalType = " << setprecision(indent) << m_terminalType << '\n';
  11065.   if (HasOptionalField(e_terminalAlias))
  11066.     strm << setw(indent+16) << "terminalAlias = " << setprecision(indent) << m_terminalAlias << '\n';
  11067.   if (HasOptionalField(e_gatekeeperIdentifier))
  11068.     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  11069.   strm << setw(indent+17) << "endpointVendor = " << setprecision(indent) << m_endpointVendor << '\n';
  11070.   if (HasOptionalField(e_alternateEndpoints))
  11071.     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
  11072.   if (HasOptionalField(e_timeToLive))
  11073.     strm << setw(indent+13) << "timeToLive = " << setprecision(indent) << m_timeToLive << '\n';
  11074.   if (HasOptionalField(e_tokens))
  11075.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  11076.   if (HasOptionalField(e_cryptoTokens))
  11077.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  11078.   if (HasOptionalField(e_integrityCheckValue))
  11079.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  11080.   if (HasOptionalField(e_keepAlive))
  11081.     strm << setw(indent+12) << "keepAlive = " << setprecision(indent) << m_keepAlive << '\n';
  11082.   if (HasOptionalField(e_endpointIdentifier))
  11083.     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  11084.   if (HasOptionalField(e_willSupplyUUIEs))
  11085.     strm << setw(indent+18) << "willSupplyUUIEs = " << setprecision(indent) << m_willSupplyUUIEs << '\n';
  11086.   if (HasOptionalField(e_maintainConnection))
  11087.     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
  11088.   if (HasOptionalField(e_alternateTransportAddresses))
  11089.     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
  11090.   if (HasOptionalField(e_additiveRegistration))
  11091.     strm << setw(indent+23) << "additiveRegistration = " << setprecision(indent) << m_additiveRegistration << '\n';
  11092.   if (HasOptionalField(e_terminalAliasPattern))
  11093.     strm << setw(indent+23) << "terminalAliasPattern = " << setprecision(indent) << m_terminalAliasPattern << '\n';
  11094.   if (HasOptionalField(e_supportsAltGK))
  11095.     strm << setw(indent+16) << "supportsAltGK = " << setprecision(indent) << m_supportsAltGK << '\n';
  11096.   if (HasOptionalField(e_usageReportingCapability))
  11097.     strm << setw(indent+27) << "usageReportingCapability = " << setprecision(indent) << m_usageReportingCapability << '\n';
  11098.   if (HasOptionalField(e_multipleCalls))
  11099.     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
  11100.   if (HasOptionalField(e_supportedH248Packages))
  11101.     strm << setw(indent+24) << "supportedH248Packages = " << setprecision(indent) << m_supportedH248Packages << '\n';
  11102.   if (HasOptionalField(e_callCreditCapability))
  11103.     strm << setw(indent+23) << "callCreditCapability = " << setprecision(indent) << m_callCreditCapability << '\n';
  11104.   if (HasOptionalField(e_capacityReportingCapability))
  11105.     strm << setw(indent+30) << "capacityReportingCapability = " << setprecision(indent) << m_capacityReportingCapability << '\n';
  11106.   if (HasOptionalField(e_capacity))
  11107.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  11108.   if (HasOptionalField(e_featureSet))
  11109.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  11110.   if (HasOptionalField(e_genericData))
  11111.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  11112.   strm << setw(indent-1) << "}";
  11113. }
  11114. #endif
  11115.  
  11116.  
  11117. PObject::Comparison H225_RegistrationRequest::Compare(const PObject & obj) const
  11118. {
  11119. #ifndef PASN_LEANANDMEAN
  11120.   PAssert(IsDescendant(H225_RegistrationRequest::Class()), PInvalidCast);
  11121. #endif
  11122.   const H225_RegistrationRequest & other = (const H225_RegistrationRequest &)obj;
  11123.  
  11124.   Comparison result;
  11125.  
  11126.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  11127.     return result;
  11128.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  11129.     return result;
  11130.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  11131.     return result;
  11132.   if ((result = m_discoveryComplete.Compare(other.m_discoveryComplete)) != EqualTo)
  11133.     return result;
  11134.   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
  11135.     return result;
  11136.   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
  11137.     return result;
  11138.   if ((result = m_terminalType.Compare(other.m_terminalType)) != EqualTo)
  11139.     return result;
  11140.   if ((result = m_terminalAlias.Compare(other.m_terminalAlias)) != EqualTo)
  11141.     return result;
  11142.   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
  11143.     return result;
  11144.   if ((result = m_endpointVendor.Compare(other.m_endpointVendor)) != EqualTo)
  11145.     return result;
  11146.  
  11147.   return PASN_Sequence::Compare(other);
  11148. }
  11149.  
  11150.  
  11151. PINDEX H225_RegistrationRequest::GetDataLength() const
  11152. {
  11153.   PINDEX length = 0;
  11154.   length += m_requestSeqNum.GetObjectLength();
  11155.   length += m_protocolIdentifier.GetObjectLength();
  11156.   if (HasOptionalField(e_nonStandardData))
  11157.     length += m_nonStandardData.GetObjectLength();
  11158.   length += m_discoveryComplete.GetObjectLength();
  11159.   length += m_callSignalAddress.GetObjectLength();
  11160.   length += m_rasAddress.GetObjectLength();
  11161.   length += m_terminalType.GetObjectLength();
  11162.   if (HasOptionalField(e_terminalAlias))
  11163.     length += m_terminalAlias.GetObjectLength();
  11164.   if (HasOptionalField(e_gatekeeperIdentifier))
  11165.     length += m_gatekeeperIdentifier.GetObjectLength();
  11166.   length += m_endpointVendor.GetObjectLength();
  11167.   return length;
  11168. }
  11169.  
  11170.  
  11171. BOOL H225_RegistrationRequest::Decode(PASN_Stream & strm)
  11172. {
  11173.   if (!PreambleDecode(strm))
  11174.     return FALSE;
  11175.  
  11176.   if (!m_requestSeqNum.Decode(strm))
  11177.     return FALSE;
  11178.   if (!m_protocolIdentifier.Decode(strm))
  11179.     return FALSE;
  11180.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  11181.     return FALSE;
  11182.   if (!m_discoveryComplete.Decode(strm))
  11183.     return FALSE;
  11184.   if (!m_callSignalAddress.Decode(strm))
  11185.     return FALSE;
  11186.   if (!m_rasAddress.Decode(strm))
  11187.     return FALSE;
  11188.   if (!m_terminalType.Decode(strm))
  11189.     return FALSE;
  11190.   if (HasOptionalField(e_terminalAlias) && !m_terminalAlias.Decode(strm))
  11191.     return FALSE;
  11192.   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
  11193.     return FALSE;
  11194.   if (!m_endpointVendor.Decode(strm))
  11195.     return FALSE;
  11196.   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
  11197.     return FALSE;
  11198.   if (!KnownExtensionDecode(strm, e_timeToLive, m_timeToLive))
  11199.     return FALSE;
  11200.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  11201.     return FALSE;
  11202.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  11203.     return FALSE;
  11204.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  11205.     return FALSE;
  11206.   if (!KnownExtensionDecode(strm, e_keepAlive, m_keepAlive))
  11207.     return FALSE;
  11208.   if (!KnownExtensionDecode(strm, e_endpointIdentifier, m_endpointIdentifier))
  11209.     return FALSE;
  11210.   if (!KnownExtensionDecode(strm, e_willSupplyUUIEs, m_willSupplyUUIEs))
  11211.     return FALSE;
  11212.   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
  11213.     return FALSE;
  11214.   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
  11215.     return FALSE;
  11216.   if (!KnownExtensionDecode(strm, e_additiveRegistration, m_additiveRegistration))
  11217.     return FALSE;
  11218.   if (!KnownExtensionDecode(strm, e_terminalAliasPattern, m_terminalAliasPattern))
  11219.     return FALSE;
  11220.   if (!KnownExtensionDecode(strm, e_supportsAltGK, m_supportsAltGK))
  11221.     return FALSE;
  11222.   if (!KnownExtensionDecode(strm, e_usageReportingCapability, m_usageReportingCapability))
  11223.     return FALSE;
  11224.   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
  11225.     return FALSE;
  11226.   if (!KnownExtensionDecode(strm, e_supportedH248Packages, m_supportedH248Packages))
  11227.     return FALSE;
  11228.   if (!KnownExtensionDecode(strm, e_callCreditCapability, m_callCreditCapability))
  11229.     return FALSE;
  11230.   if (!KnownExtensionDecode(strm, e_capacityReportingCapability, m_capacityReportingCapability))
  11231.     return FALSE;
  11232.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  11233.     return FALSE;
  11234.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  11235.     return FALSE;
  11236.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  11237.     return FALSE;
  11238.  
  11239.   return UnknownExtensionsDecode(strm);
  11240. }
  11241.  
  11242.  
  11243. void H225_RegistrationRequest::Encode(PASN_Stream & strm) const
  11244. {
  11245.   PreambleEncode(strm);
  11246.  
  11247.   m_requestSeqNum.Encode(strm);
  11248.   m_protocolIdentifier.Encode(strm);
  11249.   if (HasOptionalField(e_nonStandardData))
  11250.     m_nonStandardData.Encode(strm);
  11251.   m_discoveryComplete.Encode(strm);
  11252.   m_callSignalAddress.Encode(strm);
  11253.   m_rasAddress.Encode(strm);
  11254.   m_terminalType.Encode(strm);
  11255.   if (HasOptionalField(e_terminalAlias))
  11256.     m_terminalAlias.Encode(strm);
  11257.   if (HasOptionalField(e_gatekeeperIdentifier))
  11258.     m_gatekeeperIdentifier.Encode(strm);
  11259.   m_endpointVendor.Encode(strm);
  11260.   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
  11261.   KnownExtensionEncode(strm, e_timeToLive, m_timeToLive);
  11262.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  11263.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  11264.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  11265.   KnownExtensionEncode(strm, e_keepAlive, m_keepAlive);
  11266.   KnownExtensionEncode(strm, e_endpointIdentifier, m_endpointIdentifier);
  11267.   KnownExtensionEncode(strm, e_willSupplyUUIEs, m_willSupplyUUIEs);
  11268.   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
  11269.   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
  11270.   KnownExtensionEncode(strm, e_additiveRegistration, m_additiveRegistration);
  11271.   KnownExtensionEncode(strm, e_terminalAliasPattern, m_terminalAliasPattern);
  11272.   KnownExtensionEncode(strm, e_supportsAltGK, m_supportsAltGK);
  11273.   KnownExtensionEncode(strm, e_usageReportingCapability, m_usageReportingCapability);
  11274.   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
  11275.   KnownExtensionEncode(strm, e_supportedH248Packages, m_supportedH248Packages);
  11276.   KnownExtensionEncode(strm, e_callCreditCapability, m_callCreditCapability);
  11277.   KnownExtensionEncode(strm, e_capacityReportingCapability, m_capacityReportingCapability);
  11278.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  11279.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  11280.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  11281.  
  11282.   UnknownExtensionsEncode(strm);
  11283. }
  11284.  
  11285.  
  11286. PObject * H225_RegistrationRequest::Clone() const
  11287. {
  11288. #ifndef PASN_LEANANDMEAN
  11289.   PAssert(IsClass(H225_RegistrationRequest::Class()), PInvalidCast);
  11290. #endif
  11291.   return new H225_RegistrationRequest(*this);
  11292. }
  11293.  
  11294.  
  11295. //
  11296. // AdmissionConfirm
  11297. //
  11298.  
  11299. H225_AdmissionConfirm::H225_AdmissionConfirm(unsigned tag, PASN_Object::TagClass tagClass)
  11300.   : PASN_Sequence(tag, tagClass, 2, TRUE, 21)
  11301. {
  11302.   m_irrFrequency.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
  11303.   IncludeOptionalField(e_willRespondToIRR);
  11304.   IncludeOptionalField(e_uuiesRequested);
  11305. }
  11306.  
  11307.  
  11308. #ifndef PASN_NOPRINTON
  11309. void H225_AdmissionConfirm::PrintOn(ostream & strm) const
  11310. {
  11311.   int indent = strm.precision() + 2;
  11312.   strm << "{\n";
  11313.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  11314.   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
  11315.   strm << setw(indent+12) << "callModel = " << setprecision(indent) << m_callModel << '\n';
  11316.   strm << setw(indent+24) << "destCallSignalAddress = " << setprecision(indent) << m_destCallSignalAddress << '\n';
  11317.   if (HasOptionalField(e_irrFrequency))
  11318.     strm << setw(indent+15) << "irrFrequency = " << setprecision(indent) << m_irrFrequency << '\n';
  11319.   if (HasOptionalField(e_nonStandardData))
  11320.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  11321.   if (HasOptionalField(e_destinationInfo))
  11322.     strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
  11323.   if (HasOptionalField(e_destExtraCallInfo))
  11324.     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
  11325.   if (HasOptionalField(e_destinationType))
  11326.     strm << setw(indent+18) << "destinationType = " << setprecision(indent) << m_destinationType << '\n';
  11327.   if (HasOptionalField(e_remoteExtensionAddress))
  11328.     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
  11329.   if (HasOptionalField(e_alternateEndpoints))
  11330.     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
  11331.   if (HasOptionalField(e_tokens))
  11332.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  11333.   if (HasOptionalField(e_cryptoTokens))
  11334.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  11335.   if (HasOptionalField(e_integrityCheckValue))
  11336.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  11337.   if (HasOptionalField(e_transportQOS))
  11338.     strm << setw(indent+15) << "transportQOS = " << setprecision(indent) << m_transportQOS << '\n';
  11339.   if (HasOptionalField(e_willRespondToIRR))
  11340.     strm << setw(indent+19) << "willRespondToIRR = " << setprecision(indent) << m_willRespondToIRR << '\n';
  11341.   if (HasOptionalField(e_uuiesRequested))
  11342.     strm << setw(indent+17) << "uuiesRequested = " << setprecision(indent) << m_uuiesRequested << '\n';
  11343.   if (HasOptionalField(e_language))
  11344.     strm << setw(indent+11) << "language = " << setprecision(indent) << m_language << '\n';
  11345.   if (HasOptionalField(e_alternateTransportAddresses))
  11346.     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
  11347.   if (HasOptionalField(e_useSpecifiedTransport))
  11348.     strm << setw(indent+24) << "useSpecifiedTransport = " << setprecision(indent) << m_useSpecifiedTransport << '\n';
  11349.   if (HasOptionalField(e_circuitInfo))
  11350.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  11351.   if (HasOptionalField(e_usageSpec))
  11352.     strm << setw(indent+12) << "usageSpec = " << setprecision(indent) << m_usageSpec << '\n';
  11353.   if (HasOptionalField(e_supportedProtocols))
  11354.     strm << setw(indent+21) << "supportedProtocols = " << setprecision(indent) << m_supportedProtocols << '\n';
  11355.   if (HasOptionalField(e_serviceControl))
  11356.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  11357.   if (HasOptionalField(e_multipleCalls))
  11358.     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
  11359.   if (HasOptionalField(e_featureSet))
  11360.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  11361.   if (HasOptionalField(e_genericData))
  11362.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  11363.   strm << setw(indent-1) << "}";
  11364. }
  11365. #endif
  11366.  
  11367.  
  11368. PObject::Comparison H225_AdmissionConfirm::Compare(const PObject & obj) const
  11369. {
  11370. #ifndef PASN_LEANANDMEAN
  11371.   PAssert(IsDescendant(H225_AdmissionConfirm::Class()), PInvalidCast);
  11372. #endif
  11373.   const H225_AdmissionConfirm & other = (const H225_AdmissionConfirm &)obj;
  11374.  
  11375.   Comparison result;
  11376.  
  11377.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  11378.     return result;
  11379.   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
  11380.     return result;
  11381.   if ((result = m_callModel.Compare(other.m_callModel)) != EqualTo)
  11382.     return result;
  11383.   if ((result = m_destCallSignalAddress.Compare(other.m_destCallSignalAddress)) != EqualTo)
  11384.     return result;
  11385.   if ((result = m_irrFrequency.Compare(other.m_irrFrequency)) != EqualTo)
  11386.     return result;
  11387.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  11388.     return result;
  11389.  
  11390.   return PASN_Sequence::Compare(other);
  11391. }
  11392.  
  11393.  
  11394. PINDEX H225_AdmissionConfirm::GetDataLength() const
  11395. {
  11396.   PINDEX length = 0;
  11397.   length += m_requestSeqNum.GetObjectLength();
  11398.   length += m_bandWidth.GetObjectLength();
  11399.   length += m_callModel.GetObjectLength();
  11400.   length += m_destCallSignalAddress.GetObjectLength();
  11401.   if (HasOptionalField(e_irrFrequency))
  11402.     length += m_irrFrequency.GetObjectLength();
  11403.   if (HasOptionalField(e_nonStandardData))
  11404.     length += m_nonStandardData.GetObjectLength();
  11405.   return length;
  11406. }
  11407.  
  11408.  
  11409. BOOL H225_AdmissionConfirm::Decode(PASN_Stream & strm)
  11410. {
  11411.   if (!PreambleDecode(strm))
  11412.     return FALSE;
  11413.  
  11414.   if (!m_requestSeqNum.Decode(strm))
  11415.     return FALSE;
  11416.   if (!m_bandWidth.Decode(strm))
  11417.     return FALSE;
  11418.   if (!m_callModel.Decode(strm))
  11419.     return FALSE;
  11420.   if (!m_destCallSignalAddress.Decode(strm))
  11421.     return FALSE;
  11422.   if (HasOptionalField(e_irrFrequency) && !m_irrFrequency.Decode(strm))
  11423.     return FALSE;
  11424.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  11425.     return FALSE;
  11426.   if (!KnownExtensionDecode(strm, e_destinationInfo, m_destinationInfo))
  11427.     return FALSE;
  11428.   if (!KnownExtensionDecode(strm, e_destExtraCallInfo, m_destExtraCallInfo))
  11429.     return FALSE;
  11430.   if (!KnownExtensionDecode(strm, e_destinationType, m_destinationType))
  11431.     return FALSE;
  11432.   if (!KnownExtensionDecode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress))
  11433.     return FALSE;
  11434.   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
  11435.     return FALSE;
  11436.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  11437.     return FALSE;
  11438.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  11439.     return FALSE;
  11440.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  11441.     return FALSE;
  11442.   if (!KnownExtensionDecode(strm, e_transportQOS, m_transportQOS))
  11443.     return FALSE;
  11444.   if (!KnownExtensionDecode(strm, e_willRespondToIRR, m_willRespondToIRR))
  11445.     return FALSE;
  11446.   if (!KnownExtensionDecode(strm, e_uuiesRequested, m_uuiesRequested))
  11447.     return FALSE;
  11448.   if (!KnownExtensionDecode(strm, e_language, m_language))
  11449.     return FALSE;
  11450.   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
  11451.     return FALSE;
  11452.   if (!KnownExtensionDecode(strm, e_useSpecifiedTransport, m_useSpecifiedTransport))
  11453.     return FALSE;
  11454.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  11455.     return FALSE;
  11456.   if (!KnownExtensionDecode(strm, e_usageSpec, m_usageSpec))
  11457.     return FALSE;
  11458.   if (!KnownExtensionDecode(strm, e_supportedProtocols, m_supportedProtocols))
  11459.     return FALSE;
  11460.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  11461.     return FALSE;
  11462.   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
  11463.     return FALSE;
  11464.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  11465.     return FALSE;
  11466.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  11467.     return FALSE;
  11468.  
  11469.   return UnknownExtensionsDecode(strm);
  11470. }
  11471.  
  11472.  
  11473. void H225_AdmissionConfirm::Encode(PASN_Stream & strm) const
  11474. {
  11475.   PreambleEncode(strm);
  11476.  
  11477.   m_requestSeqNum.Encode(strm);
  11478.   m_bandWidth.Encode(strm);
  11479.   m_callModel.Encode(strm);
  11480.   m_destCallSignalAddress.Encode(strm);
  11481.   if (HasOptionalField(e_irrFrequency))
  11482.     m_irrFrequency.Encode(strm);
  11483.   if (HasOptionalField(e_nonStandardData))
  11484.     m_nonStandardData.Encode(strm);
  11485.   KnownExtensionEncode(strm, e_destinationInfo, m_destinationInfo);
  11486.   KnownExtensionEncode(strm, e_destExtraCallInfo, m_destExtraCallInfo);
  11487.   KnownExtensionEncode(strm, e_destinationType, m_destinationType);
  11488.   KnownExtensionEncode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress);
  11489.   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
  11490.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  11491.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  11492.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  11493.   KnownExtensionEncode(strm, e_transportQOS, m_transportQOS);
  11494.   KnownExtensionEncode(strm, e_willRespondToIRR, m_willRespondToIRR);
  11495.   KnownExtensionEncode(strm, e_uuiesRequested, m_uuiesRequested);
  11496.   KnownExtensionEncode(strm, e_language, m_language);
  11497.   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
  11498.   KnownExtensionEncode(strm, e_useSpecifiedTransport, m_useSpecifiedTransport);
  11499.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  11500.   KnownExtensionEncode(strm, e_usageSpec, m_usageSpec);
  11501.   KnownExtensionEncode(strm, e_supportedProtocols, m_supportedProtocols);
  11502.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  11503.   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
  11504.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  11505.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  11506.  
  11507.   UnknownExtensionsEncode(strm);
  11508. }
  11509.  
  11510.  
  11511. PObject * H225_AdmissionConfirm::Clone() const
  11512. {
  11513. #ifndef PASN_LEANANDMEAN
  11514.   PAssert(IsClass(H225_AdmissionConfirm::Class()), PInvalidCast);
  11515. #endif
  11516.   return new H225_AdmissionConfirm(*this);
  11517. }
  11518.  
  11519.  
  11520. //
  11521. // LocationConfirm
  11522. //
  11523.  
  11524. H225_LocationConfirm::H225_LocationConfirm(unsigned tag, PASN_Object::TagClass tagClass)
  11525.   : PASN_Sequence(tag, tagClass, 1, TRUE, 15)
  11526. {
  11527. }
  11528.  
  11529.  
  11530. #ifndef PASN_NOPRINTON
  11531. void H225_LocationConfirm::PrintOn(ostream & strm) const
  11532. {
  11533.   int indent = strm.precision() + 2;
  11534.   strm << "{\n";
  11535.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  11536.   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
  11537.   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
  11538.   if (HasOptionalField(e_nonStandardData))
  11539.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  11540.   if (HasOptionalField(e_destinationInfo))
  11541.     strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
  11542.   if (HasOptionalField(e_destExtraCallInfo))
  11543.     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
  11544.   if (HasOptionalField(e_destinationType))
  11545.     strm << setw(indent+18) << "destinationType = " << setprecision(indent) << m_destinationType << '\n';
  11546.   if (HasOptionalField(e_remoteExtensionAddress))
  11547.     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
  11548.   if (HasOptionalField(e_alternateEndpoints))
  11549.     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
  11550.   if (HasOptionalField(e_tokens))
  11551.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  11552.   if (HasOptionalField(e_cryptoTokens))
  11553.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  11554.   if (HasOptionalField(e_integrityCheckValue))
  11555.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  11556.   if (HasOptionalField(e_alternateTransportAddresses))
  11557.     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
  11558.   if (HasOptionalField(e_supportedProtocols))
  11559.     strm << setw(indent+21) << "supportedProtocols = " << setprecision(indent) << m_supportedProtocols << '\n';
  11560.   if (HasOptionalField(e_multipleCalls))
  11561.     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
  11562.   if (HasOptionalField(e_featureSet))
  11563.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  11564.   if (HasOptionalField(e_genericData))
  11565.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  11566.   if (HasOptionalField(e_circuitInfo))
  11567.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  11568.   if (HasOptionalField(e_serviceControl))
  11569.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  11570.   strm << setw(indent-1) << "}";
  11571. }
  11572. #endif
  11573.  
  11574.  
  11575. PObject::Comparison H225_LocationConfirm::Compare(const PObject & obj) const
  11576. {
  11577. #ifndef PASN_LEANANDMEAN
  11578.   PAssert(IsDescendant(H225_LocationConfirm::Class()), PInvalidCast);
  11579. #endif
  11580.   const H225_LocationConfirm & other = (const H225_LocationConfirm &)obj;
  11581.  
  11582.   Comparison result;
  11583.  
  11584.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  11585.     return result;
  11586.   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
  11587.     return result;
  11588.   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
  11589.     return result;
  11590.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  11591.     return result;
  11592.  
  11593.   return PASN_Sequence::Compare(other);
  11594. }
  11595.  
  11596.  
  11597. PINDEX H225_LocationConfirm::GetDataLength() const
  11598. {
  11599.   PINDEX length = 0;
  11600.   length += m_requestSeqNum.GetObjectLength();
  11601.   length += m_callSignalAddress.GetObjectLength();
  11602.   length += m_rasAddress.GetObjectLength();
  11603.   if (HasOptionalField(e_nonStandardData))
  11604.     length += m_nonStandardData.GetObjectLength();
  11605.   return length;
  11606. }
  11607.  
  11608.  
  11609. BOOL H225_LocationConfirm::Decode(PASN_Stream & strm)
  11610. {
  11611.   if (!PreambleDecode(strm))
  11612.     return FALSE;
  11613.  
  11614.   if (!m_requestSeqNum.Decode(strm))
  11615.     return FALSE;
  11616.   if (!m_callSignalAddress.Decode(strm))
  11617.     return FALSE;
  11618.   if (!m_rasAddress.Decode(strm))
  11619.     return FALSE;
  11620.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  11621.     return FALSE;
  11622.   if (!KnownExtensionDecode(strm, e_destinationInfo, m_destinationInfo))
  11623.     return FALSE;
  11624.   if (!KnownExtensionDecode(strm, e_destExtraCallInfo, m_destExtraCallInfo))
  11625.     return FALSE;
  11626.   if (!KnownExtensionDecode(strm, e_destinationType, m_destinationType))
  11627.     return FALSE;
  11628.   if (!KnownExtensionDecode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress))
  11629.     return FALSE;
  11630.   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
  11631.     return FALSE;
  11632.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  11633.     return FALSE;
  11634.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  11635.     return FALSE;
  11636.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  11637.     return FALSE;
  11638.   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
  11639.     return FALSE;
  11640.   if (!KnownExtensionDecode(strm, e_supportedProtocols, m_supportedProtocols))
  11641.     return FALSE;
  11642.   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
  11643.     return FALSE;
  11644.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  11645.     return FALSE;
  11646.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  11647.     return FALSE;
  11648.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  11649.     return FALSE;
  11650.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  11651.     return FALSE;
  11652.  
  11653.   return UnknownExtensionsDecode(strm);
  11654. }
  11655.  
  11656.  
  11657. void H225_LocationConfirm::Encode(PASN_Stream & strm) const
  11658. {
  11659.   PreambleEncode(strm);
  11660.  
  11661.   m_requestSeqNum.Encode(strm);
  11662.   m_callSignalAddress.Encode(strm);
  11663.   m_rasAddress.Encode(strm);
  11664.   if (HasOptionalField(e_nonStandardData))
  11665.     m_nonStandardData.Encode(strm);
  11666.   KnownExtensionEncode(strm, e_destinationInfo, m_destinationInfo);
  11667.   KnownExtensionEncode(strm, e_destExtraCallInfo, m_destExtraCallInfo);
  11668.   KnownExtensionEncode(strm, e_destinationType, m_destinationType);
  11669.   KnownExtensionEncode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress);
  11670.   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
  11671.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  11672.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  11673.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  11674.   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
  11675.   KnownExtensionEncode(strm, e_supportedProtocols, m_supportedProtocols);
  11676.   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
  11677.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  11678.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  11679.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  11680.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  11681.  
  11682.   UnknownExtensionsEncode(strm);
  11683. }
  11684.  
  11685.  
  11686. PObject * H225_LocationConfirm::Clone() const
  11687. {
  11688. #ifndef PASN_LEANANDMEAN
  11689.   PAssert(IsClass(H225_LocationConfirm::Class()), PInvalidCast);
  11690. #endif
  11691.   return new H225_LocationConfirm(*this);
  11692. }
  11693.  
  11694.  
  11695. //
  11696. // InfoRequestResponse
  11697. //
  11698.  
  11699. H225_InfoRequestResponse::H225_InfoRequestResponse(unsigned tag, PASN_Object::TagClass tagClass)
  11700.   : PASN_Sequence(tag, tagClass, 3, TRUE, 8)
  11701. {
  11702.   IncludeOptionalField(e_needResponse);
  11703.   IncludeOptionalField(e_unsolicited);
  11704. }
  11705.  
  11706.  
  11707. #ifndef PASN_NOPRINTON
  11708. void H225_InfoRequestResponse::PrintOn(ostream & strm) const
  11709. {
  11710.   int indent = strm.precision() + 2;
  11711.   strm << "{\n";
  11712.   if (HasOptionalField(e_nonStandardData))
  11713.     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  11714.   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
  11715.   strm << setw(indent+15) << "endpointType = " << setprecision(indent) << m_endpointType << '\n';
  11716.   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  11717.   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
  11718.   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
  11719.   if (HasOptionalField(e_endpointAlias))
  11720.     strm << setw(indent+16) << "endpointAlias = " << setprecision(indent) << m_endpointAlias << '\n';
  11721.   if (HasOptionalField(e_perCallInfo))
  11722.     strm << setw(indent+14) << "perCallInfo = " << setprecision(indent) << m_perCallInfo << '\n';
  11723.   if (HasOptionalField(e_tokens))
  11724.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  11725.   if (HasOptionalField(e_cryptoTokens))
  11726.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  11727.   if (HasOptionalField(e_integrityCheckValue))
  11728.     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
  11729.   if (HasOptionalField(e_needResponse))
  11730.     strm << setw(indent+15) << "needResponse = " << setprecision(indent) << m_needResponse << '\n';
  11731.   if (HasOptionalField(e_capacity))
  11732.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  11733.   if (HasOptionalField(e_irrStatus))
  11734.     strm << setw(indent+12) << "irrStatus = " << setprecision(indent) << m_irrStatus << '\n';
  11735.   if (HasOptionalField(e_unsolicited))
  11736.     strm << setw(indent+14) << "unsolicited = " << setprecision(indent) << m_unsolicited << '\n';
  11737.   if (HasOptionalField(e_genericData))
  11738.     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
  11739.   strm << setw(indent-1) << "}";
  11740. }
  11741. #endif
  11742.  
  11743.  
  11744. PObject::Comparison H225_InfoRequestResponse::Compare(const PObject & obj) const
  11745. {
  11746. #ifndef PASN_LEANANDMEAN
  11747.   PAssert(IsDescendant(H225_InfoRequestResponse::Class()), PInvalidCast);
  11748. #endif
  11749.   const H225_InfoRequestResponse & other = (const H225_InfoRequestResponse &)obj;
  11750.  
  11751.   Comparison result;
  11752.  
  11753.   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
  11754.     return result;
  11755.   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
  11756.     return result;
  11757.   if ((result = m_endpointType.Compare(other.m_endpointType)) != EqualTo)
  11758.     return result;
  11759.   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
  11760.     return result;
  11761.   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
  11762.     return result;
  11763.   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
  11764.     return result;
  11765.   if ((result = m_endpointAlias.Compare(other.m_endpointAlias)) != EqualTo)
  11766.     return result;
  11767.   if ((result = m_perCallInfo.Compare(other.m_perCallInfo)) != EqualTo)
  11768.     return result;
  11769.  
  11770.   return PASN_Sequence::Compare(other);
  11771. }
  11772.  
  11773.  
  11774. PINDEX H225_InfoRequestResponse::GetDataLength() const
  11775. {
  11776.   PINDEX length = 0;
  11777.   if (HasOptionalField(e_nonStandardData))
  11778.     length += m_nonStandardData.GetObjectLength();
  11779.   length += m_requestSeqNum.GetObjectLength();
  11780.   length += m_endpointType.GetObjectLength();
  11781.   length += m_endpointIdentifier.GetObjectLength();
  11782.   length += m_rasAddress.GetObjectLength();
  11783.   length += m_callSignalAddress.GetObjectLength();
  11784.   if (HasOptionalField(e_endpointAlias))
  11785.     length += m_endpointAlias.GetObjectLength();
  11786.   if (HasOptionalField(e_perCallInfo))
  11787.     length += m_perCallInfo.GetObjectLength();
  11788.   return length;
  11789. }
  11790.  
  11791.  
  11792. BOOL H225_InfoRequestResponse::Decode(PASN_Stream & strm)
  11793. {
  11794.   if (!PreambleDecode(strm))
  11795.     return FALSE;
  11796.  
  11797.   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
  11798.     return FALSE;
  11799.   if (!m_requestSeqNum.Decode(strm))
  11800.     return FALSE;
  11801.   if (!m_endpointType.Decode(strm))
  11802.     return FALSE;
  11803.   if (!m_endpointIdentifier.Decode(strm))
  11804.     return FALSE;
  11805.   if (!m_rasAddress.Decode(strm))
  11806.     return FALSE;
  11807.   if (!m_callSignalAddress.Decode(strm))
  11808.     return FALSE;
  11809.   if (HasOptionalField(e_endpointAlias) && !m_endpointAlias.Decode(strm))
  11810.     return FALSE;
  11811.   if (HasOptionalField(e_perCallInfo) && !m_perCallInfo.Decode(strm))
  11812.     return FALSE;
  11813.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  11814.     return FALSE;
  11815.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  11816.     return FALSE;
  11817.   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
  11818.     return FALSE;
  11819.   if (!KnownExtensionDecode(strm, e_needResponse, m_needResponse))
  11820.     return FALSE;
  11821.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  11822.     return FALSE;
  11823.   if (!KnownExtensionDecode(strm, e_irrStatus, m_irrStatus))
  11824.     return FALSE;
  11825.   if (!KnownExtensionDecode(strm, e_unsolicited, m_unsolicited))
  11826.     return FALSE;
  11827.   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
  11828.     return FALSE;
  11829.  
  11830.   return UnknownExtensionsDecode(strm);
  11831. }
  11832.  
  11833.  
  11834. void H225_InfoRequestResponse::Encode(PASN_Stream & strm) const
  11835. {
  11836.   PreambleEncode(strm);
  11837.  
  11838.   if (HasOptionalField(e_nonStandardData))
  11839.     m_nonStandardData.Encode(strm);
  11840.   m_requestSeqNum.Encode(strm);
  11841.   m_endpointType.Encode(strm);
  11842.   m_endpointIdentifier.Encode(strm);
  11843.   m_rasAddress.Encode(strm);
  11844.   m_callSignalAddress.Encode(strm);
  11845.   if (HasOptionalField(e_endpointAlias))
  11846.     m_endpointAlias.Encode(strm);
  11847.   if (HasOptionalField(e_perCallInfo))
  11848.     m_perCallInfo.Encode(strm);
  11849.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  11850.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  11851.   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
  11852.   KnownExtensionEncode(strm, e_needResponse, m_needResponse);
  11853.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  11854.   KnownExtensionEncode(strm, e_irrStatus, m_irrStatus);
  11855.   KnownExtensionEncode(strm, e_unsolicited, m_unsolicited);
  11856.   KnownExtensionEncode(strm, e_genericData, m_genericData);
  11857.  
  11858.   UnknownExtensionsEncode(strm);
  11859. }
  11860.  
  11861.  
  11862. PObject * H225_InfoRequestResponse::Clone() const
  11863. {
  11864. #ifndef PASN_LEANANDMEAN
  11865.   PAssert(IsClass(H225_InfoRequestResponse::Class()), PInvalidCast);
  11866. #endif
  11867.   return new H225_InfoRequestResponse(*this);
  11868. }
  11869.  
  11870.  
  11871. //
  11872. // InfoRequestResponse_perCallInfo_subtype_pdu_subtype
  11873. //
  11874.  
  11875. H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  11876.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  11877. {
  11878. }
  11879.  
  11880.  
  11881. #ifndef PASN_NOPRINTON
  11882. void H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::PrintOn(ostream & strm) const
  11883. {
  11884.   int indent = strm.precision() + 2;
  11885.   strm << "{\n";
  11886.   strm << setw(indent+10) << "h323pdu = " << setprecision(indent) << m_h323pdu << '\n';
  11887.   strm << setw(indent+7) << "sent = " << setprecision(indent) << m_sent << '\n';
  11888.   strm << setw(indent-1) << "}";
  11889. }
  11890. #endif
  11891.  
  11892.  
  11893. PObject::Comparison H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Compare(const PObject & obj) const
  11894. {
  11895. #ifndef PASN_LEANANDMEAN
  11896.   PAssert(IsDescendant(H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Class()), PInvalidCast);
  11897. #endif
  11898.   const H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype & other = (const H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype &)obj;
  11899.  
  11900.   Comparison result;
  11901.  
  11902.   if ((result = m_h323pdu.Compare(other.m_h323pdu)) != EqualTo)
  11903.     return result;
  11904.   if ((result = m_sent.Compare(other.m_sent)) != EqualTo)
  11905.     return result;
  11906.  
  11907.   return PASN_Sequence::Compare(other);
  11908. }
  11909.  
  11910.  
  11911. PINDEX H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::GetDataLength() const
  11912. {
  11913.   PINDEX length = 0;
  11914.   length += m_h323pdu.GetObjectLength();
  11915.   length += m_sent.GetObjectLength();
  11916.   return length;
  11917. }
  11918.  
  11919.  
  11920. BOOL H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Decode(PASN_Stream & strm)
  11921. {
  11922.   if (!PreambleDecode(strm))
  11923.     return FALSE;
  11924.  
  11925.   if (!m_h323pdu.Decode(strm))
  11926.     return FALSE;
  11927.   if (!m_sent.Decode(strm))
  11928.     return FALSE;
  11929.  
  11930.   return UnknownExtensionsDecode(strm);
  11931. }
  11932.  
  11933.  
  11934. void H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Encode(PASN_Stream & strm) const
  11935. {
  11936.   PreambleEncode(strm);
  11937.  
  11938.   m_h323pdu.Encode(strm);
  11939.   m_sent.Encode(strm);
  11940.  
  11941.   UnknownExtensionsEncode(strm);
  11942. }
  11943.  
  11944.  
  11945. PObject * H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Clone() const
  11946. {
  11947. #ifndef PASN_LEANANDMEAN
  11948.   PAssert(IsClass(H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Class()), PInvalidCast);
  11949. #endif
  11950.   return new H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype(*this);
  11951. }
  11952.  
  11953.  
  11954. //
  11955. // H323-UserInformation
  11956. //
  11957.  
  11958. H225_H323_UserInformation::H225_H323_UserInformation(unsigned tag, PASN_Object::TagClass tagClass)
  11959.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  11960. {
  11961. }
  11962.  
  11963.  
  11964. #ifndef PASN_NOPRINTON
  11965. void H225_H323_UserInformation::PrintOn(ostream & strm) const
  11966. {
  11967.   int indent = strm.precision() + 2;
  11968.   strm << "{\n";
  11969.   strm << setw(indent+14) << "h323_uu_pdu = " << setprecision(indent) << m_h323_uu_pdu << '\n';
  11970.   if (HasOptionalField(e_user_data))
  11971.     strm << setw(indent+12) << "user_data = " << setprecision(indent) << m_user_data << '\n';
  11972.   strm << setw(indent-1) << "}";
  11973. }
  11974. #endif
  11975.  
  11976.  
  11977. PObject::Comparison H225_H323_UserInformation::Compare(const PObject & obj) const
  11978. {
  11979. #ifndef PASN_LEANANDMEAN
  11980.   PAssert(IsDescendant(H225_H323_UserInformation::Class()), PInvalidCast);
  11981. #endif
  11982.   const H225_H323_UserInformation & other = (const H225_H323_UserInformation &)obj;
  11983.  
  11984.   Comparison result;
  11985.  
  11986.   if ((result = m_h323_uu_pdu.Compare(other.m_h323_uu_pdu)) != EqualTo)
  11987.     return result;
  11988.   if ((result = m_user_data.Compare(other.m_user_data)) != EqualTo)
  11989.     return result;
  11990.  
  11991.   return PASN_Sequence::Compare(other);
  11992. }
  11993.  
  11994.  
  11995. PINDEX H225_H323_UserInformation::GetDataLength() const
  11996. {
  11997.   PINDEX length = 0;
  11998.   length += m_h323_uu_pdu.GetObjectLength();
  11999.   if (HasOptionalField(e_user_data))
  12000.     length += m_user_data.GetObjectLength();
  12001.   return length;
  12002. }
  12003.  
  12004.  
  12005. BOOL H225_H323_UserInformation::Decode(PASN_Stream & strm)
  12006. {
  12007.   if (!PreambleDecode(strm))
  12008.     return FALSE;
  12009.  
  12010.   if (!m_h323_uu_pdu.Decode(strm))
  12011.     return FALSE;
  12012.   if (HasOptionalField(e_user_data) && !m_user_data.Decode(strm))
  12013.     return FALSE;
  12014.  
  12015.   return UnknownExtensionsDecode(strm);
  12016. }
  12017.  
  12018.  
  12019. void H225_H323_UserInformation::Encode(PASN_Stream & strm) const
  12020. {
  12021.   PreambleEncode(strm);
  12022.  
  12023.   m_h323_uu_pdu.Encode(strm);
  12024.   if (HasOptionalField(e_user_data))
  12025.     m_user_data.Encode(strm);
  12026.  
  12027.   UnknownExtensionsEncode(strm);
  12028. }
  12029.  
  12030.  
  12031. PObject * H225_H323_UserInformation::Clone() const
  12032. {
  12033. #ifndef PASN_LEANANDMEAN
  12034.   PAssert(IsClass(H225_H323_UserInformation::Class()), PInvalidCast);
  12035. #endif
  12036.   return new H225_H323_UserInformation(*this);
  12037. }
  12038.  
  12039.  
  12040. //
  12041. // Alerting-UUIE
  12042. //
  12043.  
  12044. H225_Alerting_UUIE::H225_Alerting_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  12045.   : PASN_Sequence(tag, tagClass, 1, TRUE, 14)
  12046. {
  12047.   IncludeOptionalField(e_callIdentifier);
  12048.   IncludeOptionalField(e_multipleCalls);
  12049.   IncludeOptionalField(e_maintainConnection);
  12050. }
  12051.  
  12052.  
  12053. #ifndef PASN_NOPRINTON
  12054. void H225_Alerting_UUIE::PrintOn(ostream & strm) const
  12055. {
  12056.   int indent = strm.precision() + 2;
  12057.   strm << "{\n";
  12058.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  12059.   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
  12060.   if (HasOptionalField(e_h245Address))
  12061.     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
  12062.   if (HasOptionalField(e_callIdentifier))
  12063.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  12064.   if (HasOptionalField(e_h245SecurityMode))
  12065.     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
  12066.   if (HasOptionalField(e_tokens))
  12067.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  12068.   if (HasOptionalField(e_cryptoTokens))
  12069.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  12070.   if (HasOptionalField(e_fastStart))
  12071.     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
  12072.   if (HasOptionalField(e_multipleCalls))
  12073.     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
  12074.   if (HasOptionalField(e_maintainConnection))
  12075.     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
  12076.   if (HasOptionalField(e_alertingAddress))
  12077.     strm << setw(indent+18) << "alertingAddress = " << setprecision(indent) << m_alertingAddress << '\n';
  12078.   if (HasOptionalField(e_presentationIndicator))
  12079.     strm << setw(indent+24) << "presentationIndicator = " << setprecision(indent) << m_presentationIndicator << '\n';
  12080.   if (HasOptionalField(e_screeningIndicator))
  12081.     strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
  12082.   if (HasOptionalField(e_fastConnectRefused))
  12083.     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
  12084.   if (HasOptionalField(e_serviceControl))
  12085.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  12086.   if (HasOptionalField(e_capacity))
  12087.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  12088.   if (HasOptionalField(e_featureSet))
  12089.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  12090.   strm << setw(indent-1) << "}";
  12091. }
  12092. #endif
  12093.  
  12094.  
  12095. PObject::Comparison H225_Alerting_UUIE::Compare(const PObject & obj) const
  12096. {
  12097. #ifndef PASN_LEANANDMEAN
  12098.   PAssert(IsDescendant(H225_Alerting_UUIE::Class()), PInvalidCast);
  12099. #endif
  12100.   const H225_Alerting_UUIE & other = (const H225_Alerting_UUIE &)obj;
  12101.  
  12102.   Comparison result;
  12103.  
  12104.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  12105.     return result;
  12106.   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
  12107.     return result;
  12108.   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
  12109.     return result;
  12110.  
  12111.   return PASN_Sequence::Compare(other);
  12112. }
  12113.  
  12114.  
  12115. PINDEX H225_Alerting_UUIE::GetDataLength() const
  12116. {
  12117.   PINDEX length = 0;
  12118.   length += m_protocolIdentifier.GetObjectLength();
  12119.   length += m_destinationInfo.GetObjectLength();
  12120.   if (HasOptionalField(e_h245Address))
  12121.     length += m_h245Address.GetObjectLength();
  12122.   return length;
  12123. }
  12124.  
  12125.  
  12126. BOOL H225_Alerting_UUIE::Decode(PASN_Stream & strm)
  12127. {
  12128.   if (!PreambleDecode(strm))
  12129.     return FALSE;
  12130.  
  12131.   if (!m_protocolIdentifier.Decode(strm))
  12132.     return FALSE;
  12133.   if (!m_destinationInfo.Decode(strm))
  12134.     return FALSE;
  12135.   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
  12136.     return FALSE;
  12137.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  12138.     return FALSE;
  12139.   if (!KnownExtensionDecode(strm, e_h245SecurityMode, m_h245SecurityMode))
  12140.     return FALSE;
  12141.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  12142.     return FALSE;
  12143.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  12144.     return FALSE;
  12145.   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
  12146.     return FALSE;
  12147.   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
  12148.     return FALSE;
  12149.   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
  12150.     return FALSE;
  12151.   if (!KnownExtensionDecode(strm, e_alertingAddress, m_alertingAddress))
  12152.     return FALSE;
  12153.   if (!KnownExtensionDecode(strm, e_presentationIndicator, m_presentationIndicator))
  12154.     return FALSE;
  12155.   if (!KnownExtensionDecode(strm, e_screeningIndicator, m_screeningIndicator))
  12156.     return FALSE;
  12157.   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
  12158.     return FALSE;
  12159.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  12160.     return FALSE;
  12161.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  12162.     return FALSE;
  12163.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  12164.     return FALSE;
  12165.  
  12166.   return UnknownExtensionsDecode(strm);
  12167. }
  12168.  
  12169.  
  12170. void H225_Alerting_UUIE::Encode(PASN_Stream & strm) const
  12171. {
  12172.   PreambleEncode(strm);
  12173.  
  12174.   m_protocolIdentifier.Encode(strm);
  12175.   m_destinationInfo.Encode(strm);
  12176.   if (HasOptionalField(e_h245Address))
  12177.     m_h245Address.Encode(strm);
  12178.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  12179.   KnownExtensionEncode(strm, e_h245SecurityMode, m_h245SecurityMode);
  12180.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  12181.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  12182.   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
  12183.   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
  12184.   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
  12185.   KnownExtensionEncode(strm, e_alertingAddress, m_alertingAddress);
  12186.   KnownExtensionEncode(strm, e_presentationIndicator, m_presentationIndicator);
  12187.   KnownExtensionEncode(strm, e_screeningIndicator, m_screeningIndicator);
  12188.   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
  12189.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  12190.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  12191.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  12192.  
  12193.   UnknownExtensionsEncode(strm);
  12194. }
  12195.  
  12196.  
  12197. PObject * H225_Alerting_UUIE::Clone() const
  12198. {
  12199. #ifndef PASN_LEANANDMEAN
  12200.   PAssert(IsClass(H225_Alerting_UUIE::Class()), PInvalidCast);
  12201. #endif
  12202.   return new H225_Alerting_UUIE(*this);
  12203. }
  12204.  
  12205.  
  12206. //
  12207. // CallProceeding-UUIE
  12208. //
  12209.  
  12210. H225_CallProceeding_UUIE::H225_CallProceeding_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  12211.   : PASN_Sequence(tag, tagClass, 1, TRUE, 9)
  12212. {
  12213.   IncludeOptionalField(e_callIdentifier);
  12214.   IncludeOptionalField(e_multipleCalls);
  12215.   IncludeOptionalField(e_maintainConnection);
  12216. }
  12217.  
  12218.  
  12219. #ifndef PASN_NOPRINTON
  12220. void H225_CallProceeding_UUIE::PrintOn(ostream & strm) const
  12221. {
  12222.   int indent = strm.precision() + 2;
  12223.   strm << "{\n";
  12224.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  12225.   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
  12226.   if (HasOptionalField(e_h245Address))
  12227.     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
  12228.   if (HasOptionalField(e_callIdentifier))
  12229.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  12230.   if (HasOptionalField(e_h245SecurityMode))
  12231.     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
  12232.   if (HasOptionalField(e_tokens))
  12233.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  12234.   if (HasOptionalField(e_cryptoTokens))
  12235.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  12236.   if (HasOptionalField(e_fastStart))
  12237.     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
  12238.   if (HasOptionalField(e_multipleCalls))
  12239.     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
  12240.   if (HasOptionalField(e_maintainConnection))
  12241.     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
  12242.   if (HasOptionalField(e_fastConnectRefused))
  12243.     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
  12244.   if (HasOptionalField(e_featureSet))
  12245.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  12246.   strm << setw(indent-1) << "}";
  12247. }
  12248. #endif
  12249.  
  12250.  
  12251. PObject::Comparison H225_CallProceeding_UUIE::Compare(const PObject & obj) const
  12252. {
  12253. #ifndef PASN_LEANANDMEAN
  12254.   PAssert(IsDescendant(H225_CallProceeding_UUIE::Class()), PInvalidCast);
  12255. #endif
  12256.   const H225_CallProceeding_UUIE & other = (const H225_CallProceeding_UUIE &)obj;
  12257.  
  12258.   Comparison result;
  12259.  
  12260.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  12261.     return result;
  12262.   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
  12263.     return result;
  12264.   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
  12265.     return result;
  12266.  
  12267.   return PASN_Sequence::Compare(other);
  12268. }
  12269.  
  12270.  
  12271. PINDEX H225_CallProceeding_UUIE::GetDataLength() const
  12272. {
  12273.   PINDEX length = 0;
  12274.   length += m_protocolIdentifier.GetObjectLength();
  12275.   length += m_destinationInfo.GetObjectLength();
  12276.   if (HasOptionalField(e_h245Address))
  12277.     length += m_h245Address.GetObjectLength();
  12278.   return length;
  12279. }
  12280.  
  12281.  
  12282. BOOL H225_CallProceeding_UUIE::Decode(PASN_Stream & strm)
  12283. {
  12284.   if (!PreambleDecode(strm))
  12285.     return FALSE;
  12286.  
  12287.   if (!m_protocolIdentifier.Decode(strm))
  12288.     return FALSE;
  12289.   if (!m_destinationInfo.Decode(strm))
  12290.     return FALSE;
  12291.   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
  12292.     return FALSE;
  12293.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  12294.     return FALSE;
  12295.   if (!KnownExtensionDecode(strm, e_h245SecurityMode, m_h245SecurityMode))
  12296.     return FALSE;
  12297.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  12298.     return FALSE;
  12299.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  12300.     return FALSE;
  12301.   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
  12302.     return FALSE;
  12303.   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
  12304.     return FALSE;
  12305.   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
  12306.     return FALSE;
  12307.   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
  12308.     return FALSE;
  12309.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  12310.     return FALSE;
  12311.  
  12312.   return UnknownExtensionsDecode(strm);
  12313. }
  12314.  
  12315.  
  12316. void H225_CallProceeding_UUIE::Encode(PASN_Stream & strm) const
  12317. {
  12318.   PreambleEncode(strm);
  12319.  
  12320.   m_protocolIdentifier.Encode(strm);
  12321.   m_destinationInfo.Encode(strm);
  12322.   if (HasOptionalField(e_h245Address))
  12323.     m_h245Address.Encode(strm);
  12324.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  12325.   KnownExtensionEncode(strm, e_h245SecurityMode, m_h245SecurityMode);
  12326.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  12327.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  12328.   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
  12329.   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
  12330.   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
  12331.   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
  12332.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  12333.  
  12334.   UnknownExtensionsEncode(strm);
  12335. }
  12336.  
  12337.  
  12338. PObject * H225_CallProceeding_UUIE::Clone() const
  12339. {
  12340. #ifndef PASN_LEANANDMEAN
  12341.   PAssert(IsClass(H225_CallProceeding_UUIE::Class()), PInvalidCast);
  12342. #endif
  12343.   return new H225_CallProceeding_UUIE(*this);
  12344. }
  12345.  
  12346.  
  12347. //
  12348. // Connect-UUIE
  12349. //
  12350.  
  12351. H225_Connect_UUIE::H225_Connect_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  12352.   : PASN_Sequence(tag, tagClass, 1, TRUE, 15)
  12353. {
  12354.   IncludeOptionalField(e_callIdentifier);
  12355.   IncludeOptionalField(e_multipleCalls);
  12356.   IncludeOptionalField(e_maintainConnection);
  12357. }
  12358.  
  12359.  
  12360. #ifndef PASN_NOPRINTON
  12361. void H225_Connect_UUIE::PrintOn(ostream & strm) const
  12362. {
  12363.   int indent = strm.precision() + 2;
  12364.   strm << "{\n";
  12365.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  12366.   if (HasOptionalField(e_h245Address))
  12367.     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
  12368.   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
  12369.   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  12370.   if (HasOptionalField(e_callIdentifier))
  12371.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  12372.   if (HasOptionalField(e_h245SecurityMode))
  12373.     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
  12374.   if (HasOptionalField(e_tokens))
  12375.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  12376.   if (HasOptionalField(e_cryptoTokens))
  12377.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  12378.   if (HasOptionalField(e_fastStart))
  12379.     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
  12380.   if (HasOptionalField(e_multipleCalls))
  12381.     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
  12382.   if (HasOptionalField(e_maintainConnection))
  12383.     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
  12384.   if (HasOptionalField(e_language))
  12385.     strm << setw(indent+11) << "language = " << setprecision(indent) << m_language << '\n';
  12386.   if (HasOptionalField(e_connectedAddress))
  12387.     strm << setw(indent+19) << "connectedAddress = " << setprecision(indent) << m_connectedAddress << '\n';
  12388.   if (HasOptionalField(e_presentationIndicator))
  12389.     strm << setw(indent+24) << "presentationIndicator = " << setprecision(indent) << m_presentationIndicator << '\n';
  12390.   if (HasOptionalField(e_screeningIndicator))
  12391.     strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
  12392.   if (HasOptionalField(e_fastConnectRefused))
  12393.     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
  12394.   if (HasOptionalField(e_serviceControl))
  12395.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  12396.   if (HasOptionalField(e_capacity))
  12397.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  12398.   if (HasOptionalField(e_featureSet))
  12399.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  12400.   strm << setw(indent-1) << "}";
  12401. }
  12402. #endif
  12403.  
  12404.  
  12405. PObject::Comparison H225_Connect_UUIE::Compare(const PObject & obj) const
  12406. {
  12407. #ifndef PASN_LEANANDMEAN
  12408.   PAssert(IsDescendant(H225_Connect_UUIE::Class()), PInvalidCast);
  12409. #endif
  12410.   const H225_Connect_UUIE & other = (const H225_Connect_UUIE &)obj;
  12411.  
  12412.   Comparison result;
  12413.  
  12414.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  12415.     return result;
  12416.   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
  12417.     return result;
  12418.   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
  12419.     return result;
  12420.   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
  12421.     return result;
  12422.  
  12423.   return PASN_Sequence::Compare(other);
  12424. }
  12425.  
  12426.  
  12427. PINDEX H225_Connect_UUIE::GetDataLength() const
  12428. {
  12429.   PINDEX length = 0;
  12430.   length += m_protocolIdentifier.GetObjectLength();
  12431.   if (HasOptionalField(e_h245Address))
  12432.     length += m_h245Address.GetObjectLength();
  12433.   length += m_destinationInfo.GetObjectLength();
  12434.   length += m_conferenceID.GetObjectLength();
  12435.   return length;
  12436. }
  12437.  
  12438.  
  12439. BOOL H225_Connect_UUIE::Decode(PASN_Stream & strm)
  12440. {
  12441.   if (!PreambleDecode(strm))
  12442.     return FALSE;
  12443.  
  12444.   if (!m_protocolIdentifier.Decode(strm))
  12445.     return FALSE;
  12446.   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
  12447.     return FALSE;
  12448.   if (!m_destinationInfo.Decode(strm))
  12449.     return FALSE;
  12450.   if (!m_conferenceID.Decode(strm))
  12451.     return FALSE;
  12452.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  12453.     return FALSE;
  12454.   if (!KnownExtensionDecode(strm, e_h245SecurityMode, m_h245SecurityMode))
  12455.     return FALSE;
  12456.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  12457.     return FALSE;
  12458.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  12459.     return FALSE;
  12460.   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
  12461.     return FALSE;
  12462.   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
  12463.     return FALSE;
  12464.   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
  12465.     return FALSE;
  12466.   if (!KnownExtensionDecode(strm, e_language, m_language))
  12467.     return FALSE;
  12468.   if (!KnownExtensionDecode(strm, e_connectedAddress, m_connectedAddress))
  12469.     return FALSE;
  12470.   if (!KnownExtensionDecode(strm, e_presentationIndicator, m_presentationIndicator))
  12471.     return FALSE;
  12472.   if (!KnownExtensionDecode(strm, e_screeningIndicator, m_screeningIndicator))
  12473.     return FALSE;
  12474.   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
  12475.     return FALSE;
  12476.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  12477.     return FALSE;
  12478.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  12479.     return FALSE;
  12480.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  12481.     return FALSE;
  12482.  
  12483.   return UnknownExtensionsDecode(strm);
  12484. }
  12485.  
  12486.  
  12487. void H225_Connect_UUIE::Encode(PASN_Stream & strm) const
  12488. {
  12489.   PreambleEncode(strm);
  12490.  
  12491.   m_protocolIdentifier.Encode(strm);
  12492.   if (HasOptionalField(e_h245Address))
  12493.     m_h245Address.Encode(strm);
  12494.   m_destinationInfo.Encode(strm);
  12495.   m_conferenceID.Encode(strm);
  12496.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  12497.   KnownExtensionEncode(strm, e_h245SecurityMode, m_h245SecurityMode);
  12498.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  12499.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  12500.   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
  12501.   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
  12502.   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
  12503.   KnownExtensionEncode(strm, e_language, m_language);
  12504.   KnownExtensionEncode(strm, e_connectedAddress, m_connectedAddress);
  12505.   KnownExtensionEncode(strm, e_presentationIndicator, m_presentationIndicator);
  12506.   KnownExtensionEncode(strm, e_screeningIndicator, m_screeningIndicator);
  12507.   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
  12508.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  12509.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  12510.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  12511.  
  12512.   UnknownExtensionsEncode(strm);
  12513. }
  12514.  
  12515.  
  12516. PObject * H225_Connect_UUIE::Clone() const
  12517. {
  12518. #ifndef PASN_LEANANDMEAN
  12519.   PAssert(IsClass(H225_Connect_UUIE::Class()), PInvalidCast);
  12520. #endif
  12521.   return new H225_Connect_UUIE(*this);
  12522. }
  12523.  
  12524.  
  12525. //
  12526. // Setup-UUIE
  12527. //
  12528.  
  12529. H225_Setup_UUIE::H225_Setup_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  12530.   : PASN_Sequence(tag, tagClass, 7, TRUE, 26)
  12531. {
  12532.   IncludeOptionalField(e_callIdentifier);
  12533.   IncludeOptionalField(e_mediaWaitForConnect);
  12534.   IncludeOptionalField(e_canOverlapSend);
  12535.   IncludeOptionalField(e_multipleCalls);
  12536.   IncludeOptionalField(e_maintainConnection);
  12537. }
  12538.  
  12539.  
  12540. #ifndef PASN_NOPRINTON
  12541. void H225_Setup_UUIE::PrintOn(ostream & strm) const
  12542. {
  12543.   int indent = strm.precision() + 2;
  12544.   strm << "{\n";
  12545.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  12546.   if (HasOptionalField(e_h245Address))
  12547.     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
  12548.   if (HasOptionalField(e_sourceAddress))
  12549.     strm << setw(indent+16) << "sourceAddress = " << setprecision(indent) << m_sourceAddress << '\n';
  12550.   strm << setw(indent+13) << "sourceInfo = " << setprecision(indent) << m_sourceInfo << '\n';
  12551.   if (HasOptionalField(e_destinationAddress))
  12552.     strm << setw(indent+21) << "destinationAddress = " << setprecision(indent) << m_destinationAddress << '\n';
  12553.   if (HasOptionalField(e_destCallSignalAddress))
  12554.     strm << setw(indent+24) << "destCallSignalAddress = " << setprecision(indent) << m_destCallSignalAddress << '\n';
  12555.   if (HasOptionalField(e_destExtraCallInfo))
  12556.     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
  12557.   if (HasOptionalField(e_destExtraCRV))
  12558.     strm << setw(indent+15) << "destExtraCRV = " << setprecision(indent) << m_destExtraCRV << '\n';
  12559.   strm << setw(indent+11) << "activeMC = " << setprecision(indent) << m_activeMC << '\n';
  12560.   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  12561.   strm << setw(indent+17) << "conferenceGoal = " << setprecision(indent) << m_conferenceGoal << '\n';
  12562.   if (HasOptionalField(e_callServices))
  12563.     strm << setw(indent+15) << "callServices = " << setprecision(indent) << m_callServices << '\n';
  12564.   strm << setw(indent+11) << "callType = " << setprecision(indent) << m_callType << '\n';
  12565.   if (HasOptionalField(e_sourceCallSignalAddress))
  12566.     strm << setw(indent+26) << "sourceCallSignalAddress = " << setprecision(indent) << m_sourceCallSignalAddress << '\n';
  12567.   if (HasOptionalField(e_remoteExtensionAddress))
  12568.     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
  12569.   if (HasOptionalField(e_callIdentifier))
  12570.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  12571.   if (HasOptionalField(e_h245SecurityCapability))
  12572.     strm << setw(indent+25) << "h245SecurityCapability = " << setprecision(indent) << m_h245SecurityCapability << '\n';
  12573.   if (HasOptionalField(e_tokens))
  12574.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  12575.   if (HasOptionalField(e_cryptoTokens))
  12576.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  12577.   if (HasOptionalField(e_fastStart))
  12578.     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
  12579.   if (HasOptionalField(e_mediaWaitForConnect))
  12580.     strm << setw(indent+22) << "mediaWaitForConnect = " << setprecision(indent) << m_mediaWaitForConnect << '\n';
  12581.   if (HasOptionalField(e_canOverlapSend))
  12582.     strm << setw(indent+17) << "canOverlapSend = " << setprecision(indent) << m_canOverlapSend << '\n';
  12583.   if (HasOptionalField(e_endpointIdentifier))
  12584.     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
  12585.   if (HasOptionalField(e_multipleCalls))
  12586.     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
  12587.   if (HasOptionalField(e_maintainConnection))
  12588.     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
  12589.   if (HasOptionalField(e_connectionParameters))
  12590.     strm << setw(indent+23) << "connectionParameters = " << setprecision(indent) << m_connectionParameters << '\n';
  12591.   if (HasOptionalField(e_language))
  12592.     strm << setw(indent+11) << "language = " << setprecision(indent) << m_language << '\n';
  12593.   if (HasOptionalField(e_presentationIndicator))
  12594.     strm << setw(indent+24) << "presentationIndicator = " << setprecision(indent) << m_presentationIndicator << '\n';
  12595.   if (HasOptionalField(e_screeningIndicator))
  12596.     strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
  12597.   if (HasOptionalField(e_serviceControl))
  12598.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  12599.   if (HasOptionalField(e_symmetricOperationRequired))
  12600.     strm << setw(indent+29) << "symmetricOperationRequired = " << setprecision(indent) << m_symmetricOperationRequired << '\n';
  12601.   if (HasOptionalField(e_capacity))
  12602.     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
  12603.   if (HasOptionalField(e_circuitInfo))
  12604.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  12605.   if (HasOptionalField(e_desiredProtocols))
  12606.     strm << setw(indent+19) << "desiredProtocols = " << setprecision(indent) << m_desiredProtocols << '\n';
  12607.   if (HasOptionalField(e_neededFeatures))
  12608.     strm << setw(indent+17) << "neededFeatures = " << setprecision(indent) << m_neededFeatures << '\n';
  12609.   if (HasOptionalField(e_desiredFeatures))
  12610.     strm << setw(indent+18) << "desiredFeatures = " << setprecision(indent) << m_desiredFeatures << '\n';
  12611.   if (HasOptionalField(e_supportedFeatures))
  12612.     strm << setw(indent+20) << "supportedFeatures = " << setprecision(indent) << m_supportedFeatures << '\n';
  12613.   if (HasOptionalField(e_parallelH245Control))
  12614.     strm << setw(indent+22) << "parallelH245Control = " << setprecision(indent) << m_parallelH245Control << '\n';
  12615.   if (HasOptionalField(e_additionalSourceAddresses))
  12616.     strm << setw(indent+28) << "additionalSourceAddresses = " << setprecision(indent) << m_additionalSourceAddresses << '\n';
  12617.   strm << setw(indent-1) << "}";
  12618. }
  12619. #endif
  12620.  
  12621.  
  12622. PObject::Comparison H225_Setup_UUIE::Compare(const PObject & obj) const
  12623. {
  12624. #ifndef PASN_LEANANDMEAN
  12625.   PAssert(IsDescendant(H225_Setup_UUIE::Class()), PInvalidCast);
  12626. #endif
  12627.   const H225_Setup_UUIE & other = (const H225_Setup_UUIE &)obj;
  12628.  
  12629.   Comparison result;
  12630.  
  12631.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  12632.     return result;
  12633.   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
  12634.     return result;
  12635.   if ((result = m_sourceAddress.Compare(other.m_sourceAddress)) != EqualTo)
  12636.     return result;
  12637.   if ((result = m_sourceInfo.Compare(other.m_sourceInfo)) != EqualTo)
  12638.     return result;
  12639.   if ((result = m_destinationAddress.Compare(other.m_destinationAddress)) != EqualTo)
  12640.     return result;
  12641.   if ((result = m_destCallSignalAddress.Compare(other.m_destCallSignalAddress)) != EqualTo)
  12642.     return result;
  12643.   if ((result = m_destExtraCallInfo.Compare(other.m_destExtraCallInfo)) != EqualTo)
  12644.     return result;
  12645.   if ((result = m_destExtraCRV.Compare(other.m_destExtraCRV)) != EqualTo)
  12646.     return result;
  12647.   if ((result = m_activeMC.Compare(other.m_activeMC)) != EqualTo)
  12648.     return result;
  12649.   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
  12650.     return result;
  12651.   if ((result = m_conferenceGoal.Compare(other.m_conferenceGoal)) != EqualTo)
  12652.     return result;
  12653.   if ((result = m_callServices.Compare(other.m_callServices)) != EqualTo)
  12654.     return result;
  12655.   if ((result = m_callType.Compare(other.m_callType)) != EqualTo)
  12656.     return result;
  12657.  
  12658.   return PASN_Sequence::Compare(other);
  12659. }
  12660.  
  12661.  
  12662. PINDEX H225_Setup_UUIE::GetDataLength() const
  12663. {
  12664.   PINDEX length = 0;
  12665.   length += m_protocolIdentifier.GetObjectLength();
  12666.   if (HasOptionalField(e_h245Address))
  12667.     length += m_h245Address.GetObjectLength();
  12668.   if (HasOptionalField(e_sourceAddress))
  12669.     length += m_sourceAddress.GetObjectLength();
  12670.   length += m_sourceInfo.GetObjectLength();
  12671.   if (HasOptionalField(e_destinationAddress))
  12672.     length += m_destinationAddress.GetObjectLength();
  12673.   if (HasOptionalField(e_destCallSignalAddress))
  12674.     length += m_destCallSignalAddress.GetObjectLength();
  12675.   if (HasOptionalField(e_destExtraCallInfo))
  12676.     length += m_destExtraCallInfo.GetObjectLength();
  12677.   if (HasOptionalField(e_destExtraCRV))
  12678.     length += m_destExtraCRV.GetObjectLength();
  12679.   length += m_activeMC.GetObjectLength();
  12680.   length += m_conferenceID.GetObjectLength();
  12681.   length += m_conferenceGoal.GetObjectLength();
  12682.   if (HasOptionalField(e_callServices))
  12683.     length += m_callServices.GetObjectLength();
  12684.   length += m_callType.GetObjectLength();
  12685.   return length;
  12686. }
  12687.  
  12688.  
  12689. BOOL H225_Setup_UUIE::Decode(PASN_Stream & strm)
  12690. {
  12691.   if (!PreambleDecode(strm))
  12692.     return FALSE;
  12693.  
  12694.   if (!m_protocolIdentifier.Decode(strm))
  12695.     return FALSE;
  12696.   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
  12697.     return FALSE;
  12698.   if (HasOptionalField(e_sourceAddress) && !m_sourceAddress.Decode(strm))
  12699.     return FALSE;
  12700.   if (!m_sourceInfo.Decode(strm))
  12701.     return FALSE;
  12702.   if (HasOptionalField(e_destinationAddress) && !m_destinationAddress.Decode(strm))
  12703.     return FALSE;
  12704.   if (HasOptionalField(e_destCallSignalAddress) && !m_destCallSignalAddress.Decode(strm))
  12705.     return FALSE;
  12706.   if (HasOptionalField(e_destExtraCallInfo) && !m_destExtraCallInfo.Decode(strm))
  12707.     return FALSE;
  12708.   if (HasOptionalField(e_destExtraCRV) && !m_destExtraCRV.Decode(strm))
  12709.     return FALSE;
  12710.   if (!m_activeMC.Decode(strm))
  12711.     return FALSE;
  12712.   if (!m_conferenceID.Decode(strm))
  12713.     return FALSE;
  12714.   if (!m_conferenceGoal.Decode(strm))
  12715.     return FALSE;
  12716.   if (HasOptionalField(e_callServices) && !m_callServices.Decode(strm))
  12717.     return FALSE;
  12718.   if (!m_callType.Decode(strm))
  12719.     return FALSE;
  12720.   if (!KnownExtensionDecode(strm, e_sourceCallSignalAddress, m_sourceCallSignalAddress))
  12721.     return FALSE;
  12722.   if (!KnownExtensionDecode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress))
  12723.     return FALSE;
  12724.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  12725.     return FALSE;
  12726.   if (!KnownExtensionDecode(strm, e_h245SecurityCapability, m_h245SecurityCapability))
  12727.     return FALSE;
  12728.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  12729.     return FALSE;
  12730.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  12731.     return FALSE;
  12732.   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
  12733.     return FALSE;
  12734.   if (!KnownExtensionDecode(strm, e_mediaWaitForConnect, m_mediaWaitForConnect))
  12735.     return FALSE;
  12736.   if (!KnownExtensionDecode(strm, e_canOverlapSend, m_canOverlapSend))
  12737.     return FALSE;
  12738.   if (!KnownExtensionDecode(strm, e_endpointIdentifier, m_endpointIdentifier))
  12739.     return FALSE;
  12740.   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
  12741.     return FALSE;
  12742.   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
  12743.     return FALSE;
  12744.   if (!KnownExtensionDecode(strm, e_connectionParameters, m_connectionParameters))
  12745.     return FALSE;
  12746.   if (!KnownExtensionDecode(strm, e_language, m_language))
  12747.     return FALSE;
  12748.   if (!KnownExtensionDecode(strm, e_presentationIndicator, m_presentationIndicator))
  12749.     return FALSE;
  12750.   if (!KnownExtensionDecode(strm, e_screeningIndicator, m_screeningIndicator))
  12751.     return FALSE;
  12752.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  12753.     return FALSE;
  12754.   if (!KnownExtensionDecode(strm, e_symmetricOperationRequired, m_symmetricOperationRequired))
  12755.     return FALSE;
  12756.   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
  12757.     return FALSE;
  12758.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  12759.     return FALSE;
  12760.   if (!KnownExtensionDecode(strm, e_desiredProtocols, m_desiredProtocols))
  12761.     return FALSE;
  12762.   if (!KnownExtensionDecode(strm, e_neededFeatures, m_neededFeatures))
  12763.     return FALSE;
  12764.   if (!KnownExtensionDecode(strm, e_desiredFeatures, m_desiredFeatures))
  12765.     return FALSE;
  12766.   if (!KnownExtensionDecode(strm, e_supportedFeatures, m_supportedFeatures))
  12767.     return FALSE;
  12768.   if (!KnownExtensionDecode(strm, e_parallelH245Control, m_parallelH245Control))
  12769.     return FALSE;
  12770.   if (!KnownExtensionDecode(strm, e_additionalSourceAddresses, m_additionalSourceAddresses))
  12771.     return FALSE;
  12772.  
  12773.   return UnknownExtensionsDecode(strm);
  12774. }
  12775.  
  12776.  
  12777. void H225_Setup_UUIE::Encode(PASN_Stream & strm) const
  12778. {
  12779.   PreambleEncode(strm);
  12780.  
  12781.   m_protocolIdentifier.Encode(strm);
  12782.   if (HasOptionalField(e_h245Address))
  12783.     m_h245Address.Encode(strm);
  12784.   if (HasOptionalField(e_sourceAddress))
  12785.     m_sourceAddress.Encode(strm);
  12786.   m_sourceInfo.Encode(strm);
  12787.   if (HasOptionalField(e_destinationAddress))
  12788.     m_destinationAddress.Encode(strm);
  12789.   if (HasOptionalField(e_destCallSignalAddress))
  12790.     m_destCallSignalAddress.Encode(strm);
  12791.   if (HasOptionalField(e_destExtraCallInfo))
  12792.     m_destExtraCallInfo.Encode(strm);
  12793.   if (HasOptionalField(e_destExtraCRV))
  12794.     m_destExtraCRV.Encode(strm);
  12795.   m_activeMC.Encode(strm);
  12796.   m_conferenceID.Encode(strm);
  12797.   m_conferenceGoal.Encode(strm);
  12798.   if (HasOptionalField(e_callServices))
  12799.     m_callServices.Encode(strm);
  12800.   m_callType.Encode(strm);
  12801.   KnownExtensionEncode(strm, e_sourceCallSignalAddress, m_sourceCallSignalAddress);
  12802.   KnownExtensionEncode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress);
  12803.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  12804.   KnownExtensionEncode(strm, e_h245SecurityCapability, m_h245SecurityCapability);
  12805.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  12806.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  12807.   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
  12808.   KnownExtensionEncode(strm, e_mediaWaitForConnect, m_mediaWaitForConnect);
  12809.   KnownExtensionEncode(strm, e_canOverlapSend, m_canOverlapSend);
  12810.   KnownExtensionEncode(strm, e_endpointIdentifier, m_endpointIdentifier);
  12811.   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
  12812.   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
  12813.   KnownExtensionEncode(strm, e_connectionParameters, m_connectionParameters);
  12814.   KnownExtensionEncode(strm, e_language, m_language);
  12815.   KnownExtensionEncode(strm, e_presentationIndicator, m_presentationIndicator);
  12816.   KnownExtensionEncode(strm, e_screeningIndicator, m_screeningIndicator);
  12817.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  12818.   KnownExtensionEncode(strm, e_symmetricOperationRequired, m_symmetricOperationRequired);
  12819.   KnownExtensionEncode(strm, e_capacity, m_capacity);
  12820.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  12821.   KnownExtensionEncode(strm, e_desiredProtocols, m_desiredProtocols);
  12822.   KnownExtensionEncode(strm, e_neededFeatures, m_neededFeatures);
  12823.   KnownExtensionEncode(strm, e_desiredFeatures, m_desiredFeatures);
  12824.   KnownExtensionEncode(strm, e_supportedFeatures, m_supportedFeatures);
  12825.   KnownExtensionEncode(strm, e_parallelH245Control, m_parallelH245Control);
  12826.   KnownExtensionEncode(strm, e_additionalSourceAddresses, m_additionalSourceAddresses);
  12827.  
  12828.   UnknownExtensionsEncode(strm);
  12829. }
  12830.  
  12831.  
  12832. PObject * H225_Setup_UUIE::Clone() const
  12833. {
  12834. #ifndef PASN_LEANANDMEAN
  12835.   PAssert(IsClass(H225_Setup_UUIE::Class()), PInvalidCast);
  12836. #endif
  12837.   return new H225_Setup_UUIE(*this);
  12838. }
  12839.  
  12840.  
  12841. //
  12842. // Facility-UUIE
  12843. //
  12844.  
  12845. H225_Facility_UUIE::H225_Facility_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  12846.   : PASN_Sequence(tag, tagClass, 3, TRUE, 16)
  12847. {
  12848.   IncludeOptionalField(e_callIdentifier);
  12849.   IncludeOptionalField(e_multipleCalls);
  12850.   IncludeOptionalField(e_maintainConnection);
  12851. }
  12852.  
  12853.  
  12854. #ifndef PASN_NOPRINTON
  12855. void H225_Facility_UUIE::PrintOn(ostream & strm) const
  12856. {
  12857.   int indent = strm.precision() + 2;
  12858.   strm << "{\n";
  12859.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  12860.   if (HasOptionalField(e_alternativeAddress))
  12861.     strm << setw(indent+21) << "alternativeAddress = " << setprecision(indent) << m_alternativeAddress << '\n';
  12862.   if (HasOptionalField(e_alternativeAliasAddress))
  12863.     strm << setw(indent+26) << "alternativeAliasAddress = " << setprecision(indent) << m_alternativeAliasAddress << '\n';
  12864.   if (HasOptionalField(e_conferenceID))
  12865.     strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  12866.   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  12867.   if (HasOptionalField(e_callIdentifier))
  12868.     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  12869.   if (HasOptionalField(e_destExtraCallInfo))
  12870.     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
  12871.   if (HasOptionalField(e_remoteExtensionAddress))
  12872.     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
  12873.   if (HasOptionalField(e_tokens))
  12874.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  12875.   if (HasOptionalField(e_cryptoTokens))
  12876.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  12877.   if (HasOptionalField(e_conferences))
  12878.     strm << setw(indent+14) << "conferences = " << setprecision(indent) << m_conferences << '\n';
  12879.   if (HasOptionalField(e_h245Address))
  12880.     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
  12881.   if (HasOptionalField(e_fastStart))
  12882.     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
  12883.   if (HasOptionalField(e_multipleCalls))
  12884.     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
  12885.   if (HasOptionalField(e_maintainConnection))
  12886.     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
  12887.   if (HasOptionalField(e_fastConnectRefused))
  12888.     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
  12889.   if (HasOptionalField(e_serviceControl))
  12890.     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
  12891.   if (HasOptionalField(e_circuitInfo))
  12892.     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
  12893.   if (HasOptionalField(e_featureSet))
  12894.     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
  12895.   if (HasOptionalField(e_destinationInfo))
  12896.     strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
  12897.   if (HasOptionalField(e_h245SecurityMode))
  12898.     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
  12899.   strm << setw(indent-1) << "}";
  12900. }
  12901. #endif
  12902.  
  12903.  
  12904. PObject::Comparison H225_Facility_UUIE::Compare(const PObject & obj) const
  12905. {
  12906. #ifndef PASN_LEANANDMEAN
  12907.   PAssert(IsDescendant(H225_Facility_UUIE::Class()), PInvalidCast);
  12908. #endif
  12909.   const H225_Facility_UUIE & other = (const H225_Facility_UUIE &)obj;
  12910.  
  12911.   Comparison result;
  12912.  
  12913.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  12914.     return result;
  12915.   if ((result = m_alternativeAddress.Compare(other.m_alternativeAddress)) != EqualTo)
  12916.     return result;
  12917.   if ((result = m_alternativeAliasAddress.Compare(other.m_alternativeAliasAddress)) != EqualTo)
  12918.     return result;
  12919.   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
  12920.     return result;
  12921.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  12922.     return result;
  12923.  
  12924.   return PASN_Sequence::Compare(other);
  12925. }
  12926.  
  12927.  
  12928. PINDEX H225_Facility_UUIE::GetDataLength() const
  12929. {
  12930.   PINDEX length = 0;
  12931.   length += m_protocolIdentifier.GetObjectLength();
  12932.   if (HasOptionalField(e_alternativeAddress))
  12933.     length += m_alternativeAddress.GetObjectLength();
  12934.   if (HasOptionalField(e_alternativeAliasAddress))
  12935.     length += m_alternativeAliasAddress.GetObjectLength();
  12936.   if (HasOptionalField(e_conferenceID))
  12937.     length += m_conferenceID.GetObjectLength();
  12938.   length += m_reason.GetObjectLength();
  12939.   return length;
  12940. }
  12941.  
  12942.  
  12943. BOOL H225_Facility_UUIE::Decode(PASN_Stream & strm)
  12944. {
  12945.   if (!PreambleDecode(strm))
  12946.     return FALSE;
  12947.  
  12948.   if (!m_protocolIdentifier.Decode(strm))
  12949.     return FALSE;
  12950.   if (HasOptionalField(e_alternativeAddress) && !m_alternativeAddress.Decode(strm))
  12951.     return FALSE;
  12952.   if (HasOptionalField(e_alternativeAliasAddress) && !m_alternativeAliasAddress.Decode(strm))
  12953.     return FALSE;
  12954.   if (HasOptionalField(e_conferenceID) && !m_conferenceID.Decode(strm))
  12955.     return FALSE;
  12956.   if (!m_reason.Decode(strm))
  12957.     return FALSE;
  12958.   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
  12959.     return FALSE;
  12960.   if (!KnownExtensionDecode(strm, e_destExtraCallInfo, m_destExtraCallInfo))
  12961.     return FALSE;
  12962.   if (!KnownExtensionDecode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress))
  12963.     return FALSE;
  12964.   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
  12965.     return FALSE;
  12966.   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
  12967.     return FALSE;
  12968.   if (!KnownExtensionDecode(strm, e_conferences, m_conferences))
  12969.     return FALSE;
  12970.   if (!KnownExtensionDecode(strm, e_h245Address, m_h245Address))
  12971.     return FALSE;
  12972.   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
  12973.     return FALSE;
  12974.   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
  12975.     return FALSE;
  12976.   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
  12977.     return FALSE;
  12978.   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
  12979.     return FALSE;
  12980.   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
  12981.     return FALSE;
  12982.   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
  12983.     return FALSE;
  12984.   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
  12985.     return FALSE;
  12986.   if (!KnownExtensionDecode(strm, e_destinationInfo, m_destinationInfo))
  12987.     return FALSE;
  12988.   if (!KnownExtensionDecode(strm, e_h245SecurityMode, m_h245SecurityMode))
  12989.     return FALSE;
  12990.  
  12991.   return UnknownExtensionsDecode(strm);
  12992. }
  12993.  
  12994.  
  12995. void H225_Facility_UUIE::Encode(PASN_Stream & strm) const
  12996. {
  12997.   PreambleEncode(strm);
  12998.  
  12999.   m_protocolIdentifier.Encode(strm);
  13000.   if (HasOptionalField(e_alternativeAddress))
  13001.     m_alternativeAddress.Encode(strm);
  13002.   if (HasOptionalField(e_alternativeAliasAddress))
  13003.     m_alternativeAliasAddress.Encode(strm);
  13004.   if (HasOptionalField(e_conferenceID))
  13005.     m_conferenceID.Encode(strm);
  13006.   m_reason.Encode(strm);
  13007.   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
  13008.   KnownExtensionEncode(strm, e_destExtraCallInfo, m_destExtraCallInfo);
  13009.   KnownExtensionEncode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress);
  13010.   KnownExtensionEncode(strm, e_tokens, m_tokens);
  13011.   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
  13012.   KnownExtensionEncode(strm, e_conferences, m_conferences);
  13013.   KnownExtensionEncode(strm, e_h245Address, m_h245Address);
  13014.   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
  13015.   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
  13016.   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
  13017.   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
  13018.   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
  13019.   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
  13020.   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
  13021.   KnownExtensionEncode(strm, e_destinationInfo, m_destinationInfo);
  13022.   KnownExtensionEncode(strm, e_h245SecurityMode, m_h245SecurityMode);
  13023.  
  13024.   UnknownExtensionsEncode(strm);
  13025. }
  13026.  
  13027.  
  13028. PObject * H225_Facility_UUIE::Clone() const
  13029. {
  13030. #ifndef PASN_LEANANDMEAN
  13031.   PAssert(IsClass(H225_Facility_UUIE::Class()), PInvalidCast);
  13032. #endif
  13033.   return new H225_Facility_UUIE(*this);
  13034. }
  13035.  
  13036.  
  13037. //
  13038. // Progress-UUIE
  13039. //
  13040.  
  13041. H225_Progress_UUIE::H225_Progress_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
  13042.   : PASN_Sequence(tag, tagClass, 5, TRUE, 3)
  13043. {
  13044.   IncludeOptionalField(e_multipleCalls);
  13045.   IncludeOptionalField(e_maintainConnection);
  13046. }
  13047.  
  13048.  
  13049. #ifndef PASN_NOPRINTON
  13050. void H225_Progress_UUIE::PrintOn(ostream & strm) const
  13051. {
  13052.   int indent = strm.precision() + 2;
  13053.   strm << "{\n";
  13054.   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  13055.   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
  13056.   if (HasOptionalField(e_h245Address))
  13057.     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
  13058.   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  13059.   if (HasOptionalField(e_h245SecurityMode))
  13060.     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
  13061.   if (HasOptionalField(e_tokens))
  13062.     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  13063.   if (HasOptionalField(e_cryptoTokens))
  13064.     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  13065.   if (HasOptionalField(e_fastStart))
  13066.     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
  13067.   if (HasOptionalField(e_multipleCalls))
  13068.     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
  13069.   if (HasOptionalField(e_maintainConnection))
  13070.     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
  13071.   if (HasOptionalField(e_fastConnectRefused))
  13072.     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
  13073.   strm << setw(indent-1) << "}";
  13074. }
  13075. #endif
  13076.  
  13077.  
  13078. PObject::Comparison H225_Progress_UUIE::Compare(const PObject & obj) const
  13079. {
  13080. #ifndef PASN_LEANANDMEAN
  13081.   PAssert(IsDescendant(H225_Progress_UUIE::Class()), PInvalidCast);
  13082. #endif
  13083.   const H225_Progress_UUIE & other = (const H225_Progress_UUIE &)obj;
  13084.  
  13085.   Comparison result;
  13086.  
  13087.   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
  13088.     return result;
  13089.   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
  13090.     return result;
  13091.   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
  13092.     return result;
  13093.   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
  13094.     return result;
  13095.   if ((result = m_h245SecurityMode.Compare(other.m_h245SecurityMode)) != EqualTo)
  13096.     return result;
  13097.   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
  13098.     return result;
  13099.   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
  13100.     return result;
  13101.   if ((result = m_fastStart.Compare(other.m_fastStart)) != EqualTo)
  13102.     return result;
  13103.  
  13104.   return PASN_Sequence::Compare(other);
  13105. }
  13106.  
  13107.  
  13108. PINDEX H225_Progress_UUIE::GetDataLength() const
  13109. {
  13110.   PINDEX length = 0;
  13111.   length += m_protocolIdentifier.GetObjectLength();
  13112.   length += m_destinationInfo.GetObjectLength();
  13113.   if (HasOptionalField(e_h245Address))
  13114.     length += m_h245Address.GetObjectLength();
  13115.   length += m_callIdentifier.GetObjectLength();
  13116.   if (HasOptionalField(e_h245SecurityMode))
  13117.     length += m_h245SecurityMode.GetObjectLength();
  13118.   if (HasOptionalField(e_tokens))
  13119.     length += m_tokens.GetObjectLength();
  13120.   if (HasOptionalField(e_cryptoTokens))
  13121.     length += m_cryptoTokens.GetObjectLength();
  13122.   if (HasOptionalField(e_fastStart))
  13123.     length += m_fastStart.GetObjectLength();
  13124.   return length;
  13125. }
  13126.  
  13127.  
  13128. BOOL H225_Progress_UUIE::Decode(PASN_Stream & strm)
  13129. {
  13130.   if (!PreambleDecode(strm))
  13131.     return FALSE;
  13132.  
  13133.   if (!m_protocolIdentifier.Decode(strm))
  13134.     return FALSE;
  13135.   if (!m_destinationInfo.Decode(strm))
  13136.     return FALSE;
  13137.   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
  13138.     return FALSE;
  13139.   if (!m_callIdentifier.Decode(strm))
  13140.     return FALSE;
  13141.   if (HasOptionalField(e_h245SecurityMode) && !m_h245SecurityMode.Decode(strm))
  13142.     return FALSE;
  13143.   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
  13144.     return FALSE;
  13145.   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
  13146.     return FALSE;
  13147.   if (HasOptionalField(e_fastStart) && !m_fastStart.Decode(strm))
  13148.     return FALSE;
  13149.   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
  13150.     return FALSE;
  13151.   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
  13152.     return FALSE;
  13153.   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
  13154.     return FALSE;
  13155.  
  13156.   return UnknownExtensionsDecode(strm);
  13157. }
  13158.  
  13159.  
  13160. void H225_Progress_UUIE::Encode(PASN_Stream & strm) const
  13161. {
  13162.   PreambleEncode(strm);
  13163.  
  13164.   m_protocolIdentifier.Encode(strm);
  13165.   m_destinationInfo.Encode(strm);
  13166.   if (HasOptionalField(e_h245Address))
  13167.     m_h245Address.Encode(strm);
  13168.   m_callIdentifier.Encode(strm);
  13169.   if (HasOptionalField(e_h245SecurityMode))
  13170.     m_h245SecurityMode.Encode(strm);
  13171.   if (HasOptionalField(e_tokens))
  13172.     m_tokens.Encode(strm);
  13173.   if (HasOptionalField(e_cryptoTokens))
  13174.     m_cryptoTokens.Encode(strm);
  13175.   if (HasOptionalField(e_fastStart))
  13176.     m_fastStart.Encode(strm);
  13177.   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
  13178.   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
  13179.   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
  13180.  
  13181.   UnknownExtensionsEncode(strm);
  13182. }
  13183.  
  13184.  
  13185. PObject * H225_Progress_UUIE::Clone() const
  13186. {
  13187. #ifndef PASN_LEANANDMEAN
  13188.   PAssert(IsClass(H225_Progress_UUIE::Class()), PInvalidCast);
  13189. #endif
  13190.   return new H225_Progress_UUIE(*this);
  13191. }
  13192.  
  13193.  
  13194. #endif // if ! H323_DISABLE_H225
  13195.  
  13196.  
  13197. // End of h225_2.cxx
  13198.