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 / mcspdu.cxx < prev    next >
C/C++ Source or Header  |  2004-06-22  |  158KB  |  7,193 lines
  1. //
  2. // mcspdu.cxx
  3. //
  4. // Code automatically generated by asnparse.
  5. //
  6.  
  7. #ifdef __GNUC__
  8. #pragma implementation "mcspdu.h"
  9. #endif
  10.  
  11. #include <ptlib.h>
  12. #include "mcspdu.h"
  13.  
  14. #define new PNEW
  15.  
  16.  
  17. #if ! H323_DISABLE_MCS
  18.  
  19. //
  20. // ChannelId
  21. //
  22.  
  23. MCS_ChannelId::MCS_ChannelId(unsigned tag, PASN_Object::TagClass tagClass)
  24.   : PASN_Integer(tag, tagClass)
  25. {
  26.   SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  27. }
  28.  
  29.  
  30. MCS_ChannelId & MCS_ChannelId::operator=(int v)
  31. {
  32.   SetValue(v);
  33.   return *this;
  34. }
  35.  
  36.  
  37. MCS_ChannelId & MCS_ChannelId::operator=(unsigned v)
  38. {
  39.   SetValue(v);
  40.   return *this;
  41. }
  42.  
  43.  
  44. PObject * MCS_ChannelId::Clone() const
  45. {
  46. #ifndef PASN_LEANANDMEAN
  47.   PAssert(IsClass(MCS_ChannelId::Class()), PInvalidCast);
  48. #endif
  49.   return new MCS_ChannelId(*this);
  50. }
  51.  
  52.  
  53. //
  54. // StaticChannelId
  55. //
  56.  
  57. MCS_StaticChannelId::MCS_StaticChannelId(unsigned tag, PASN_Object::TagClass tagClass)
  58.   : PASN_Integer(tag, tagClass)
  59. {
  60.   SetConstraints(PASN_Object::FixedConstraint, 1, 1000);
  61. }
  62.  
  63.  
  64. MCS_StaticChannelId & MCS_StaticChannelId::operator=(int v)
  65. {
  66.   SetValue(v);
  67.   return *this;
  68. }
  69.  
  70.  
  71. MCS_StaticChannelId & MCS_StaticChannelId::operator=(unsigned v)
  72. {
  73.   SetValue(v);
  74.   return *this;
  75. }
  76.  
  77.  
  78. PObject * MCS_StaticChannelId::Clone() const
  79. {
  80. #ifndef PASN_LEANANDMEAN
  81.   PAssert(IsClass(MCS_StaticChannelId::Class()), PInvalidCast);
  82. #endif
  83.   return new MCS_StaticChannelId(*this);
  84. }
  85.  
  86.  
  87. //
  88. // DynamicChannelId
  89. //
  90.  
  91. MCS_DynamicChannelId::MCS_DynamicChannelId(unsigned tag, PASN_Object::TagClass tagClass)
  92.   : PASN_Integer(tag, tagClass)
  93. {
  94.   SetConstraints(PASN_Object::FixedConstraint, 1001, 65535);
  95. }
  96.  
  97.  
  98. MCS_DynamicChannelId & MCS_DynamicChannelId::operator=(int v)
  99. {
  100.   SetValue(v);
  101.   return *this;
  102. }
  103.  
  104.  
  105. MCS_DynamicChannelId & MCS_DynamicChannelId::operator=(unsigned v)
  106. {
  107.   SetValue(v);
  108.   return *this;
  109. }
  110.  
  111.  
  112. PObject * MCS_DynamicChannelId::Clone() const
  113. {
  114. #ifndef PASN_LEANANDMEAN
  115.   PAssert(IsClass(MCS_DynamicChannelId::Class()), PInvalidCast);
  116. #endif
  117.   return new MCS_DynamicChannelId(*this);
  118. }
  119.  
  120.  
  121. //
  122. // UserId
  123. //
  124.  
  125. MCS_UserId::MCS_UserId(unsigned tag, PASN_Object::TagClass tagClass)
  126.   : MCS_DynamicChannelId(tag, tagClass)
  127. {
  128. }
  129.  
  130.  
  131. MCS_UserId & MCS_UserId::operator=(int v)
  132. {
  133.   SetValue(v);
  134.   return *this;
  135. }
  136.  
  137.  
  138. MCS_UserId & MCS_UserId::operator=(unsigned v)
  139. {
  140.   SetValue(v);
  141.   return *this;
  142. }
  143.  
  144.  
  145. PObject * MCS_UserId::Clone() const
  146. {
  147. #ifndef PASN_LEANANDMEAN
  148.   PAssert(IsClass(MCS_UserId::Class()), PInvalidCast);
  149. #endif
  150.   return new MCS_UserId(*this);
  151. }
  152.  
  153.  
  154. //
  155. // PrivateChannelId
  156. //
  157.  
  158. MCS_PrivateChannelId::MCS_PrivateChannelId(unsigned tag, PASN_Object::TagClass tagClass)
  159.   : MCS_DynamicChannelId(tag, tagClass)
  160. {
  161. }
  162.  
  163.  
  164. MCS_PrivateChannelId & MCS_PrivateChannelId::operator=(int v)
  165. {
  166.   SetValue(v);
  167.   return *this;
  168. }
  169.  
  170.  
  171. MCS_PrivateChannelId & MCS_PrivateChannelId::operator=(unsigned v)
  172. {
  173.   SetValue(v);
  174.   return *this;
  175. }
  176.  
  177.  
  178. PObject * MCS_PrivateChannelId::Clone() const
  179. {
  180. #ifndef PASN_LEANANDMEAN
  181.   PAssert(IsClass(MCS_PrivateChannelId::Class()), PInvalidCast);
  182. #endif
  183.   return new MCS_PrivateChannelId(*this);
  184. }
  185.  
  186.  
  187. //
  188. // AssignedChannelId
  189. //
  190.  
  191. MCS_AssignedChannelId::MCS_AssignedChannelId(unsigned tag, PASN_Object::TagClass tagClass)
  192.   : MCS_DynamicChannelId(tag, tagClass)
  193. {
  194. }
  195.  
  196.  
  197. MCS_AssignedChannelId & MCS_AssignedChannelId::operator=(int v)
  198. {
  199.   SetValue(v);
  200.   return *this;
  201. }
  202.  
  203.  
  204. MCS_AssignedChannelId & MCS_AssignedChannelId::operator=(unsigned v)
  205. {
  206.   SetValue(v);
  207.   return *this;
  208. }
  209.  
  210.  
  211. PObject * MCS_AssignedChannelId::Clone() const
  212. {
  213. #ifndef PASN_LEANANDMEAN
  214.   PAssert(IsClass(MCS_AssignedChannelId::Class()), PInvalidCast);
  215. #endif
  216.   return new MCS_AssignedChannelId(*this);
  217. }
  218.  
  219.  
  220. //
  221. // TokenId
  222. //
  223.  
  224. MCS_TokenId::MCS_TokenId(unsigned tag, PASN_Object::TagClass tagClass)
  225.   : PASN_Integer(tag, tagClass)
  226. {
  227.   SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
  228. }
  229.  
  230.  
  231. MCS_TokenId & MCS_TokenId::operator=(int v)
  232. {
  233.   SetValue(v);
  234.   return *this;
  235. }
  236.  
  237.  
  238. MCS_TokenId & MCS_TokenId::operator=(unsigned v)
  239. {
  240.   SetValue(v);
  241.   return *this;
  242. }
  243.  
  244.  
  245. PObject * MCS_TokenId::Clone() const
  246. {
  247. #ifndef PASN_LEANANDMEAN
  248.   PAssert(IsClass(MCS_TokenId::Class()), PInvalidCast);
  249. #endif
  250.   return new MCS_TokenId(*this);
  251. }
  252.  
  253.  
  254. //
  255. // TokenStatus
  256. //
  257.  
  258. MCS_TokenStatus::MCS_TokenStatus(unsigned tag, PASN_Object::TagClass tagClass)
  259.   : PASN_Enumeration(tag, tagClass, 7, FALSE
  260. #ifndef PASN_NOPRINTON
  261.       , "notInUse "
  262.         "selfGrabbed "
  263.         "otherGrabbed "
  264.         "selfInhibited "
  265.         "otherInhibited "
  266.         "selfRecipient "
  267.         "selfGiving "
  268.         "otherGiving "
  269. #endif
  270.     )
  271. {
  272. }
  273.  
  274.  
  275. MCS_TokenStatus & MCS_TokenStatus::operator=(unsigned v)
  276. {
  277.   SetValue(v);
  278.   return *this;
  279. }
  280.  
  281.  
  282. PObject * MCS_TokenStatus::Clone() const
  283. {
  284. #ifndef PASN_LEANANDMEAN
  285.   PAssert(IsClass(MCS_TokenStatus::Class()), PInvalidCast);
  286. #endif
  287.   return new MCS_TokenStatus(*this);
  288. }
  289.  
  290.  
  291. //
  292. // DataPriority
  293. //
  294.  
  295. MCS_DataPriority::MCS_DataPriority(unsigned tag, PASN_Object::TagClass tagClass)
  296.   : PASN_Enumeration(tag, tagClass, 3, FALSE
  297. #ifndef PASN_NOPRINTON
  298.       , "top "
  299.         "high "
  300.         "medium "
  301.         "low "
  302. #endif
  303.     )
  304. {
  305. }
  306.  
  307.  
  308. MCS_DataPriority & MCS_DataPriority::operator=(unsigned v)
  309. {
  310.   SetValue(v);
  311.   return *this;
  312. }
  313.  
  314.  
  315. PObject * MCS_DataPriority::Clone() const
  316. {
  317. #ifndef PASN_LEANANDMEAN
  318.   PAssert(IsClass(MCS_DataPriority::Class()), PInvalidCast);
  319. #endif
  320.   return new MCS_DataPriority(*this);
  321. }
  322.  
  323.  
  324. //
  325. // Segmentation
  326. //
  327.  
  328. MCS_Segmentation::MCS_Segmentation(unsigned tag, PASN_Object::TagClass tagClass)
  329.   : PASN_BitString(tag, tagClass)
  330. {
  331.   SetConstraints(PASN_Object::FixedConstraint, 2);
  332. }
  333.  
  334.  
  335. PObject * MCS_Segmentation::Clone() const
  336. {
  337. #ifndef PASN_LEANANDMEAN
  338.   PAssert(IsClass(MCS_Segmentation::Class()), PInvalidCast);
  339. #endif
  340.   return new MCS_Segmentation(*this);
  341. }
  342.  
  343.  
  344. //
  345. // DomainParameters
  346. //
  347.  
  348. MCS_DomainParameters::MCS_DomainParameters(unsigned tag, PASN_Object::TagClass tagClass)
  349.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  350. {
  351.   m_maxChannelIds.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  352.   m_maxUserIds.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  353.   m_maxTokenIds.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  354.   m_numPriorities.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  355.   m_minThroughput.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  356.   m_maxHeight.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  357.   m_maxMCSPDUsize.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  358.   m_protocolVersion.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  359. }
  360.  
  361.  
  362. #ifndef PASN_NOPRINTON
  363. void MCS_DomainParameters::PrintOn(ostream & strm) const
  364. {
  365.   int indent = strm.precision() + 2;
  366.   strm << "{\n";
  367.   strm << setw(indent+16) << "maxChannelIds = " << setprecision(indent) << m_maxChannelIds << '\n';
  368.   strm << setw(indent+13) << "maxUserIds = " << setprecision(indent) << m_maxUserIds << '\n';
  369.   strm << setw(indent+14) << "maxTokenIds = " << setprecision(indent) << m_maxTokenIds << '\n';
  370.   strm << setw(indent+16) << "numPriorities = " << setprecision(indent) << m_numPriorities << '\n';
  371.   strm << setw(indent+16) << "minThroughput = " << setprecision(indent) << m_minThroughput << '\n';
  372.   strm << setw(indent+12) << "maxHeight = " << setprecision(indent) << m_maxHeight << '\n';
  373.   strm << setw(indent+16) << "maxMCSPDUsize = " << setprecision(indent) << m_maxMCSPDUsize << '\n';
  374.   strm << setw(indent+18) << "protocolVersion = " << setprecision(indent) << m_protocolVersion << '\n';
  375.   strm << setw(indent-1) << "}";
  376. }
  377. #endif
  378.  
  379.  
  380. PObject::Comparison MCS_DomainParameters::Compare(const PObject & obj) const
  381. {
  382. #ifndef PASN_LEANANDMEAN
  383.   PAssert(IsDescendant(MCS_DomainParameters::Class()), PInvalidCast);
  384. #endif
  385.   const MCS_DomainParameters & other = (const MCS_DomainParameters &)obj;
  386.  
  387.   Comparison result;
  388.  
  389.   if ((result = m_maxChannelIds.Compare(other.m_maxChannelIds)) != EqualTo)
  390.     return result;
  391.   if ((result = m_maxUserIds.Compare(other.m_maxUserIds)) != EqualTo)
  392.     return result;
  393.   if ((result = m_maxTokenIds.Compare(other.m_maxTokenIds)) != EqualTo)
  394.     return result;
  395.   if ((result = m_numPriorities.Compare(other.m_numPriorities)) != EqualTo)
  396.     return result;
  397.   if ((result = m_minThroughput.Compare(other.m_minThroughput)) != EqualTo)
  398.     return result;
  399.   if ((result = m_maxHeight.Compare(other.m_maxHeight)) != EqualTo)
  400.     return result;
  401.   if ((result = m_maxMCSPDUsize.Compare(other.m_maxMCSPDUsize)) != EqualTo)
  402.     return result;
  403.   if ((result = m_protocolVersion.Compare(other.m_protocolVersion)) != EqualTo)
  404.     return result;
  405.  
  406.   return PASN_Sequence::Compare(other);
  407. }
  408.  
  409.  
  410. PINDEX MCS_DomainParameters::GetDataLength() const
  411. {
  412.   PINDEX length = 0;
  413.   length += m_maxChannelIds.GetObjectLength();
  414.   length += m_maxUserIds.GetObjectLength();
  415.   length += m_maxTokenIds.GetObjectLength();
  416.   length += m_numPriorities.GetObjectLength();
  417.   length += m_minThroughput.GetObjectLength();
  418.   length += m_maxHeight.GetObjectLength();
  419.   length += m_maxMCSPDUsize.GetObjectLength();
  420.   length += m_protocolVersion.GetObjectLength();
  421.   return length;
  422. }
  423.  
  424.  
  425. BOOL MCS_DomainParameters::Decode(PASN_Stream & strm)
  426. {
  427.   if (!PreambleDecode(strm))
  428.     return FALSE;
  429.  
  430.   if (!m_maxChannelIds.Decode(strm))
  431.     return FALSE;
  432.   if (!m_maxUserIds.Decode(strm))
  433.     return FALSE;
  434.   if (!m_maxTokenIds.Decode(strm))
  435.     return FALSE;
  436.   if (!m_numPriorities.Decode(strm))
  437.     return FALSE;
  438.   if (!m_minThroughput.Decode(strm))
  439.     return FALSE;
  440.   if (!m_maxHeight.Decode(strm))
  441.     return FALSE;
  442.   if (!m_maxMCSPDUsize.Decode(strm))
  443.     return FALSE;
  444.   if (!m_protocolVersion.Decode(strm))
  445.     return FALSE;
  446.  
  447.   return UnknownExtensionsDecode(strm);
  448. }
  449.  
  450.  
  451. void MCS_DomainParameters::Encode(PASN_Stream & strm) const
  452. {
  453.   PreambleEncode(strm);
  454.  
  455.   m_maxChannelIds.Encode(strm);
  456.   m_maxUserIds.Encode(strm);
  457.   m_maxTokenIds.Encode(strm);
  458.   m_numPriorities.Encode(strm);
  459.   m_minThroughput.Encode(strm);
  460.   m_maxHeight.Encode(strm);
  461.   m_maxMCSPDUsize.Encode(strm);
  462.   m_protocolVersion.Encode(strm);
  463.  
  464.   UnknownExtensionsEncode(strm);
  465. }
  466.  
  467.  
  468. PObject * MCS_DomainParameters::Clone() const
  469. {
  470. #ifndef PASN_LEANANDMEAN
  471.   PAssert(IsClass(MCS_DomainParameters::Class()), PInvalidCast);
  472. #endif
  473.   return new MCS_DomainParameters(*this);
  474. }
  475.  
  476.  
  477. //
  478. // Connect-Initial
  479. //
  480.  
  481. MCS_Connect_Initial::MCS_Connect_Initial(unsigned tag, PASN_Object::TagClass tagClass)
  482.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  483. {
  484. }
  485.  
  486.  
  487. #ifndef PASN_NOPRINTON
  488. void MCS_Connect_Initial::PrintOn(ostream & strm) const
  489. {
  490.   int indent = strm.precision() + 2;
  491.   strm << "{\n";
  492.   strm << setw(indent+24) << "callingDomainSelector = " << setprecision(indent) << m_callingDomainSelector << '\n';
  493.   strm << setw(indent+23) << "calledDomainSelector = " << setprecision(indent) << m_calledDomainSelector << '\n';
  494.   strm << setw(indent+13) << "upwardFlag = " << setprecision(indent) << m_upwardFlag << '\n';
  495.   strm << setw(indent+19) << "targetParameters = " << setprecision(indent) << m_targetParameters << '\n';
  496.   strm << setw(indent+20) << "minimumParameters = " << setprecision(indent) << m_minimumParameters << '\n';
  497.   strm << setw(indent+20) << "maximumParameters = " << setprecision(indent) << m_maximumParameters << '\n';
  498.   strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  499.   strm << setw(indent-1) << "}";
  500. }
  501. #endif
  502.  
  503.  
  504. PObject::Comparison MCS_Connect_Initial::Compare(const PObject & obj) const
  505. {
  506. #ifndef PASN_LEANANDMEAN
  507.   PAssert(IsDescendant(MCS_Connect_Initial::Class()), PInvalidCast);
  508. #endif
  509.   const MCS_Connect_Initial & other = (const MCS_Connect_Initial &)obj;
  510.  
  511.   Comparison result;
  512.  
  513.   if ((result = m_callingDomainSelector.Compare(other.m_callingDomainSelector)) != EqualTo)
  514.     return result;
  515.   if ((result = m_calledDomainSelector.Compare(other.m_calledDomainSelector)) != EqualTo)
  516.     return result;
  517.   if ((result = m_upwardFlag.Compare(other.m_upwardFlag)) != EqualTo)
  518.     return result;
  519.   if ((result = m_targetParameters.Compare(other.m_targetParameters)) != EqualTo)
  520.     return result;
  521.   if ((result = m_minimumParameters.Compare(other.m_minimumParameters)) != EqualTo)
  522.     return result;
  523.   if ((result = m_maximumParameters.Compare(other.m_maximumParameters)) != EqualTo)
  524.     return result;
  525.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  526.     return result;
  527.  
  528.   return PASN_Sequence::Compare(other);
  529. }
  530.  
  531.  
  532. PINDEX MCS_Connect_Initial::GetDataLength() const
  533. {
  534.   PINDEX length = 0;
  535.   length += m_callingDomainSelector.GetObjectLength();
  536.   length += m_calledDomainSelector.GetObjectLength();
  537.   length += m_upwardFlag.GetObjectLength();
  538.   length += m_targetParameters.GetObjectLength();
  539.   length += m_minimumParameters.GetObjectLength();
  540.   length += m_maximumParameters.GetObjectLength();
  541.   length += m_userData.GetObjectLength();
  542.   return length;
  543. }
  544.  
  545.  
  546. BOOL MCS_Connect_Initial::Decode(PASN_Stream & strm)
  547. {
  548.   if (!PreambleDecode(strm))
  549.     return FALSE;
  550.  
  551.   if (!m_callingDomainSelector.Decode(strm))
  552.     return FALSE;
  553.   if (!m_calledDomainSelector.Decode(strm))
  554.     return FALSE;
  555.   if (!m_upwardFlag.Decode(strm))
  556.     return FALSE;
  557.   if (!m_targetParameters.Decode(strm))
  558.     return FALSE;
  559.   if (!m_minimumParameters.Decode(strm))
  560.     return FALSE;
  561.   if (!m_maximumParameters.Decode(strm))
  562.     return FALSE;
  563.   if (!m_userData.Decode(strm))
  564.     return FALSE;
  565.  
  566.   return UnknownExtensionsDecode(strm);
  567. }
  568.  
  569.  
  570. void MCS_Connect_Initial::Encode(PASN_Stream & strm) const
  571. {
  572.   PreambleEncode(strm);
  573.  
  574.   m_callingDomainSelector.Encode(strm);
  575.   m_calledDomainSelector.Encode(strm);
  576.   m_upwardFlag.Encode(strm);
  577.   m_targetParameters.Encode(strm);
  578.   m_minimumParameters.Encode(strm);
  579.   m_maximumParameters.Encode(strm);
  580.   m_userData.Encode(strm);
  581.  
  582.   UnknownExtensionsEncode(strm);
  583. }
  584.  
  585.  
  586. PObject * MCS_Connect_Initial::Clone() const
  587. {
  588. #ifndef PASN_LEANANDMEAN
  589.   PAssert(IsClass(MCS_Connect_Initial::Class()), PInvalidCast);
  590. #endif
  591.   return new MCS_Connect_Initial(*this);
  592. }
  593.  
  594.  
  595. //
  596. // Connect-Additional
  597. //
  598.  
  599. MCS_Connect_Additional::MCS_Connect_Additional(unsigned tag, PASN_Object::TagClass tagClass)
  600.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  601. {
  602.   m_calledConnectId.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  603. }
  604.  
  605.  
  606. #ifndef PASN_NOPRINTON
  607. void MCS_Connect_Additional::PrintOn(ostream & strm) const
  608. {
  609.   int indent = strm.precision() + 2;
  610.   strm << "{\n";
  611.   strm << setw(indent+18) << "calledConnectId = " << setprecision(indent) << m_calledConnectId << '\n';
  612.   strm << setw(indent+15) << "dataPriority = " << setprecision(indent) << m_dataPriority << '\n';
  613.   strm << setw(indent-1) << "}";
  614. }
  615. #endif
  616.  
  617.  
  618. PObject::Comparison MCS_Connect_Additional::Compare(const PObject & obj) const
  619. {
  620. #ifndef PASN_LEANANDMEAN
  621.   PAssert(IsDescendant(MCS_Connect_Additional::Class()), PInvalidCast);
  622. #endif
  623.   const MCS_Connect_Additional & other = (const MCS_Connect_Additional &)obj;
  624.  
  625.   Comparison result;
  626.  
  627.   if ((result = m_calledConnectId.Compare(other.m_calledConnectId)) != EqualTo)
  628.     return result;
  629.   if ((result = m_dataPriority.Compare(other.m_dataPriority)) != EqualTo)
  630.     return result;
  631.  
  632.   return PASN_Sequence::Compare(other);
  633. }
  634.  
  635.  
  636. PINDEX MCS_Connect_Additional::GetDataLength() const
  637. {
  638.   PINDEX length = 0;
  639.   length += m_calledConnectId.GetObjectLength();
  640.   length += m_dataPriority.GetObjectLength();
  641.   return length;
  642. }
  643.  
  644.  
  645. BOOL MCS_Connect_Additional::Decode(PASN_Stream & strm)
  646. {
  647.   if (!PreambleDecode(strm))
  648.     return FALSE;
  649.  
  650.   if (!m_calledConnectId.Decode(strm))
  651.     return FALSE;
  652.   if (!m_dataPriority.Decode(strm))
  653.     return FALSE;
  654.  
  655.   return UnknownExtensionsDecode(strm);
  656. }
  657.  
  658.  
  659. void MCS_Connect_Additional::Encode(PASN_Stream & strm) const
  660. {
  661.   PreambleEncode(strm);
  662.  
  663.   m_calledConnectId.Encode(strm);
  664.   m_dataPriority.Encode(strm);
  665.  
  666.   UnknownExtensionsEncode(strm);
  667. }
  668.  
  669.  
  670. PObject * MCS_Connect_Additional::Clone() const
  671. {
  672. #ifndef PASN_LEANANDMEAN
  673.   PAssert(IsClass(MCS_Connect_Additional::Class()), PInvalidCast);
  674. #endif
  675.   return new MCS_Connect_Additional(*this);
  676. }
  677.  
  678.  
  679. //
  680. // PDin
  681. //
  682.  
  683. MCS_PDin::MCS_PDin(unsigned tag, PASN_Object::TagClass tagClass)
  684.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  685. {
  686.   m_heightLimit.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  687. }
  688.  
  689.  
  690. #ifndef PASN_NOPRINTON
  691. void MCS_PDin::PrintOn(ostream & strm) const
  692. {
  693.   int indent = strm.precision() + 2;
  694.   strm << "{\n";
  695.   strm << setw(indent+14) << "heightLimit = " << setprecision(indent) << m_heightLimit << '\n';
  696.   strm << setw(indent-1) << "}";
  697. }
  698. #endif
  699.  
  700.  
  701. PObject::Comparison MCS_PDin::Compare(const PObject & obj) const
  702. {
  703. #ifndef PASN_LEANANDMEAN
  704.   PAssert(IsDescendant(MCS_PDin::Class()), PInvalidCast);
  705. #endif
  706.   const MCS_PDin & other = (const MCS_PDin &)obj;
  707.  
  708.   Comparison result;
  709.  
  710.   if ((result = m_heightLimit.Compare(other.m_heightLimit)) != EqualTo)
  711.     return result;
  712.  
  713.   return PASN_Sequence::Compare(other);
  714. }
  715.  
  716.  
  717. PINDEX MCS_PDin::GetDataLength() const
  718. {
  719.   PINDEX length = 0;
  720.   length += m_heightLimit.GetObjectLength();
  721.   return length;
  722. }
  723.  
  724.  
  725. BOOL MCS_PDin::Decode(PASN_Stream & strm)
  726. {
  727.   if (!PreambleDecode(strm))
  728.     return FALSE;
  729.  
  730.   if (!m_heightLimit.Decode(strm))
  731.     return FALSE;
  732.  
  733.   return UnknownExtensionsDecode(strm);
  734. }
  735.  
  736.  
  737. void MCS_PDin::Encode(PASN_Stream & strm) const
  738. {
  739.   PreambleEncode(strm);
  740.  
  741.   m_heightLimit.Encode(strm);
  742.  
  743.   UnknownExtensionsEncode(strm);
  744. }
  745.  
  746.  
  747. PObject * MCS_PDin::Clone() const
  748. {
  749. #ifndef PASN_LEANANDMEAN
  750.   PAssert(IsClass(MCS_PDin::Class()), PInvalidCast);
  751. #endif
  752.   return new MCS_PDin(*this);
  753. }
  754.  
  755.  
  756. //
  757. // EDrq
  758. //
  759.  
  760. MCS_EDrq::MCS_EDrq(unsigned tag, PASN_Object::TagClass tagClass)
  761.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  762. {
  763.   m_subHeight.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  764.   m_subInterval.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  765. }
  766.  
  767.  
  768. #ifndef PASN_NOPRINTON
  769. void MCS_EDrq::PrintOn(ostream & strm) const
  770. {
  771.   int indent = strm.precision() + 2;
  772.   strm << "{\n";
  773.   strm << setw(indent+12) << "subHeight = " << setprecision(indent) << m_subHeight << '\n';
  774.   strm << setw(indent+14) << "subInterval = " << setprecision(indent) << m_subInterval << '\n';
  775.   strm << setw(indent-1) << "}";
  776. }
  777. #endif
  778.  
  779.  
  780. PObject::Comparison MCS_EDrq::Compare(const PObject & obj) const
  781. {
  782. #ifndef PASN_LEANANDMEAN
  783.   PAssert(IsDescendant(MCS_EDrq::Class()), PInvalidCast);
  784. #endif
  785.   const MCS_EDrq & other = (const MCS_EDrq &)obj;
  786.  
  787.   Comparison result;
  788.  
  789.   if ((result = m_subHeight.Compare(other.m_subHeight)) != EqualTo)
  790.     return result;
  791.   if ((result = m_subInterval.Compare(other.m_subInterval)) != EqualTo)
  792.     return result;
  793.  
  794.   return PASN_Sequence::Compare(other);
  795. }
  796.  
  797.  
  798. PINDEX MCS_EDrq::GetDataLength() const
  799. {
  800.   PINDEX length = 0;
  801.   length += m_subHeight.GetObjectLength();
  802.   length += m_subInterval.GetObjectLength();
  803.   return length;
  804. }
  805.  
  806.  
  807. BOOL MCS_EDrq::Decode(PASN_Stream & strm)
  808. {
  809.   if (!PreambleDecode(strm))
  810.     return FALSE;
  811.  
  812.   if (!m_subHeight.Decode(strm))
  813.     return FALSE;
  814.   if (!m_subInterval.Decode(strm))
  815.     return FALSE;
  816.  
  817.   return UnknownExtensionsDecode(strm);
  818. }
  819.  
  820.  
  821. void MCS_EDrq::Encode(PASN_Stream & strm) const
  822. {
  823.   PreambleEncode(strm);
  824.  
  825.   m_subHeight.Encode(strm);
  826.   m_subInterval.Encode(strm);
  827.  
  828.   UnknownExtensionsEncode(strm);
  829. }
  830.  
  831.  
  832. PObject * MCS_EDrq::Clone() const
  833. {
  834. #ifndef PASN_LEANANDMEAN
  835.   PAssert(IsClass(MCS_EDrq::Class()), PInvalidCast);
  836. #endif
  837.   return new MCS_EDrq(*this);
  838. }
  839.  
  840.  
  841. //
  842. // ChannelAttributes
  843. //
  844.  
  845. MCS_ChannelAttributes::MCS_ChannelAttributes(unsigned tag, PASN_Object::TagClass tagClass)
  846.   : PASN_Choice(tag, tagClass, 4, FALSE
  847. #ifndef PASN_NOPRINTON
  848.       , "static "
  849.         "userId "
  850.         "private "
  851.         "assigned "
  852. #endif
  853.     )
  854. {
  855. }
  856.  
  857.  
  858. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  859. MCS_ChannelAttributes::operator MCS_ChannelAttributes_static &() const
  860. #else
  861. MCS_ChannelAttributes::operator MCS_ChannelAttributes_static &()
  862. {
  863. #ifndef PASN_LEANANDMEAN
  864.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_ChannelAttributes_static::Class()), PInvalidCast);
  865. #endif
  866.   return *(MCS_ChannelAttributes_static *)choice;
  867. }
  868.  
  869.  
  870. MCS_ChannelAttributes::operator const MCS_ChannelAttributes_static &() const
  871. #endif
  872. {
  873. #ifndef PASN_LEANANDMEAN
  874.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_ChannelAttributes_static::Class()), PInvalidCast);
  875. #endif
  876.   return *(MCS_ChannelAttributes_static *)choice;
  877. }
  878.  
  879.  
  880. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  881. MCS_ChannelAttributes::operator MCS_ChannelAttributes_userId &() const
  882. #else
  883. MCS_ChannelAttributes::operator MCS_ChannelAttributes_userId &()
  884. {
  885. #ifndef PASN_LEANANDMEAN
  886.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_ChannelAttributes_userId::Class()), PInvalidCast);
  887. #endif
  888.   return *(MCS_ChannelAttributes_userId *)choice;
  889. }
  890.  
  891.  
  892. MCS_ChannelAttributes::operator const MCS_ChannelAttributes_userId &() const
  893. #endif
  894. {
  895. #ifndef PASN_LEANANDMEAN
  896.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_ChannelAttributes_userId::Class()), PInvalidCast);
  897. #endif
  898.   return *(MCS_ChannelAttributes_userId *)choice;
  899. }
  900.  
  901.  
  902. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  903. MCS_ChannelAttributes::operator MCS_ChannelAttributes_private &() const
  904. #else
  905. MCS_ChannelAttributes::operator MCS_ChannelAttributes_private &()
  906. {
  907. #ifndef PASN_LEANANDMEAN
  908.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_ChannelAttributes_private::Class()), PInvalidCast);
  909. #endif
  910.   return *(MCS_ChannelAttributes_private *)choice;
  911. }
  912.  
  913.  
  914. MCS_ChannelAttributes::operator const MCS_ChannelAttributes_private &() const
  915. #endif
  916. {
  917. #ifndef PASN_LEANANDMEAN
  918.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_ChannelAttributes_private::Class()), PInvalidCast);
  919. #endif
  920.   return *(MCS_ChannelAttributes_private *)choice;
  921. }
  922.  
  923.  
  924. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  925. MCS_ChannelAttributes::operator MCS_ChannelAttributes_assigned &() const
  926. #else
  927. MCS_ChannelAttributes::operator MCS_ChannelAttributes_assigned &()
  928. {
  929. #ifndef PASN_LEANANDMEAN
  930.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_ChannelAttributes_assigned::Class()), PInvalidCast);
  931. #endif
  932.   return *(MCS_ChannelAttributes_assigned *)choice;
  933. }
  934.  
  935.  
  936. MCS_ChannelAttributes::operator const MCS_ChannelAttributes_assigned &() const
  937. #endif
  938. {
  939. #ifndef PASN_LEANANDMEAN
  940.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_ChannelAttributes_assigned::Class()), PInvalidCast);
  941. #endif
  942.   return *(MCS_ChannelAttributes_assigned *)choice;
  943. }
  944.  
  945.  
  946. BOOL MCS_ChannelAttributes::CreateObject()
  947. {
  948.   switch (tag) {
  949.     case e_static :
  950.       choice = new MCS_ChannelAttributes_static();
  951.       return TRUE;
  952.     case e_userId :
  953.       choice = new MCS_ChannelAttributes_userId();
  954.       return TRUE;
  955.     case e_private :
  956.       choice = new MCS_ChannelAttributes_private();
  957.       return TRUE;
  958.     case e_assigned :
  959.       choice = new MCS_ChannelAttributes_assigned();
  960.       return TRUE;
  961.   }
  962.  
  963.   choice = NULL;
  964.   return FALSE;
  965. }
  966.  
  967.  
  968. PObject * MCS_ChannelAttributes::Clone() const
  969. {
  970. #ifndef PASN_LEANANDMEAN
  971.   PAssert(IsClass(MCS_ChannelAttributes::Class()), PInvalidCast);
  972. #endif
  973.   return new MCS_ChannelAttributes(*this);
  974. }
  975.  
  976.  
  977. //
  978. // TokenAttributes
  979. //
  980.  
  981. MCS_TokenAttributes::MCS_TokenAttributes(unsigned tag, PASN_Object::TagClass tagClass)
  982.   : PASN_Choice(tag, tagClass, 5, FALSE
  983. #ifndef PASN_NOPRINTON
  984.       , "grabbed "
  985.         "inhibited "
  986.         "giving "
  987.         "ungivable "
  988.         "given "
  989. #endif
  990.     )
  991. {
  992. }
  993.  
  994.  
  995. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  996. MCS_TokenAttributes::operator MCS_TokenAttributes_grabbed &() const
  997. #else
  998. MCS_TokenAttributes::operator MCS_TokenAttributes_grabbed &()
  999. {
  1000. #ifndef PASN_LEANANDMEAN
  1001.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_grabbed::Class()), PInvalidCast);
  1002. #endif
  1003.   return *(MCS_TokenAttributes_grabbed *)choice;
  1004. }
  1005.  
  1006.  
  1007. MCS_TokenAttributes::operator const MCS_TokenAttributes_grabbed &() const
  1008. #endif
  1009. {
  1010. #ifndef PASN_LEANANDMEAN
  1011.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_grabbed::Class()), PInvalidCast);
  1012. #endif
  1013.   return *(MCS_TokenAttributes_grabbed *)choice;
  1014. }
  1015.  
  1016.  
  1017. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1018. MCS_TokenAttributes::operator MCS_TokenAttributes_inhibited &() const
  1019. #else
  1020. MCS_TokenAttributes::operator MCS_TokenAttributes_inhibited &()
  1021. {
  1022. #ifndef PASN_LEANANDMEAN
  1023.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_inhibited::Class()), PInvalidCast);
  1024. #endif
  1025.   return *(MCS_TokenAttributes_inhibited *)choice;
  1026. }
  1027.  
  1028.  
  1029. MCS_TokenAttributes::operator const MCS_TokenAttributes_inhibited &() const
  1030. #endif
  1031. {
  1032. #ifndef PASN_LEANANDMEAN
  1033.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_inhibited::Class()), PInvalidCast);
  1034. #endif
  1035.   return *(MCS_TokenAttributes_inhibited *)choice;
  1036. }
  1037.  
  1038.  
  1039. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1040. MCS_TokenAttributes::operator MCS_TokenAttributes_giving &() const
  1041. #else
  1042. MCS_TokenAttributes::operator MCS_TokenAttributes_giving &()
  1043. {
  1044. #ifndef PASN_LEANANDMEAN
  1045.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_giving::Class()), PInvalidCast);
  1046. #endif
  1047.   return *(MCS_TokenAttributes_giving *)choice;
  1048. }
  1049.  
  1050.  
  1051. MCS_TokenAttributes::operator const MCS_TokenAttributes_giving &() const
  1052. #endif
  1053. {
  1054. #ifndef PASN_LEANANDMEAN
  1055.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_giving::Class()), PInvalidCast);
  1056. #endif
  1057.   return *(MCS_TokenAttributes_giving *)choice;
  1058. }
  1059.  
  1060.  
  1061. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1062. MCS_TokenAttributes::operator MCS_TokenAttributes_ungivable &() const
  1063. #else
  1064. MCS_TokenAttributes::operator MCS_TokenAttributes_ungivable &()
  1065. {
  1066. #ifndef PASN_LEANANDMEAN
  1067.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_ungivable::Class()), PInvalidCast);
  1068. #endif
  1069.   return *(MCS_TokenAttributes_ungivable *)choice;
  1070. }
  1071.  
  1072.  
  1073. MCS_TokenAttributes::operator const MCS_TokenAttributes_ungivable &() const
  1074. #endif
  1075. {
  1076. #ifndef PASN_LEANANDMEAN
  1077.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_ungivable::Class()), PInvalidCast);
  1078. #endif
  1079.   return *(MCS_TokenAttributes_ungivable *)choice;
  1080. }
  1081.  
  1082.  
  1083. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1084. MCS_TokenAttributes::operator MCS_TokenAttributes_given &() const
  1085. #else
  1086. MCS_TokenAttributes::operator MCS_TokenAttributes_given &()
  1087. {
  1088. #ifndef PASN_LEANANDMEAN
  1089.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_given::Class()), PInvalidCast);
  1090. #endif
  1091.   return *(MCS_TokenAttributes_given *)choice;
  1092. }
  1093.  
  1094.  
  1095. MCS_TokenAttributes::operator const MCS_TokenAttributes_given &() const
  1096. #endif
  1097. {
  1098. #ifndef PASN_LEANANDMEAN
  1099.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TokenAttributes_given::Class()), PInvalidCast);
  1100. #endif
  1101.   return *(MCS_TokenAttributes_given *)choice;
  1102. }
  1103.  
  1104.  
  1105. BOOL MCS_TokenAttributes::CreateObject()
  1106. {
  1107.   switch (tag) {
  1108.     case e_grabbed :
  1109.       choice = new MCS_TokenAttributes_grabbed();
  1110.       return TRUE;
  1111.     case e_inhibited :
  1112.       choice = new MCS_TokenAttributes_inhibited();
  1113.       return TRUE;
  1114.     case e_giving :
  1115.       choice = new MCS_TokenAttributes_giving();
  1116.       return TRUE;
  1117.     case e_ungivable :
  1118.       choice = new MCS_TokenAttributes_ungivable();
  1119.       return TRUE;
  1120.     case e_given :
  1121.       choice = new MCS_TokenAttributes_given();
  1122.       return TRUE;
  1123.   }
  1124.  
  1125.   choice = NULL;
  1126.   return FALSE;
  1127. }
  1128.  
  1129.  
  1130. PObject * MCS_TokenAttributes::Clone() const
  1131. {
  1132. #ifndef PASN_LEANANDMEAN
  1133.   PAssert(IsClass(MCS_TokenAttributes::Class()), PInvalidCast);
  1134. #endif
  1135.   return new MCS_TokenAttributes(*this);
  1136. }
  1137.  
  1138.  
  1139. //
  1140. // AUrq
  1141. //
  1142.  
  1143. MCS_AUrq::MCS_AUrq(unsigned tag, PASN_Object::TagClass tagClass)
  1144.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1145. {
  1146. }
  1147.  
  1148.  
  1149. #ifndef PASN_NOPRINTON
  1150. void MCS_AUrq::PrintOn(ostream & strm) const
  1151. {
  1152.   int indent = strm.precision() + 2;
  1153.   strm << "{\n";
  1154.   strm << setw(indent-1) << "}";
  1155. }
  1156. #endif
  1157.  
  1158.  
  1159. PINDEX MCS_AUrq::GetDataLength() const
  1160. {
  1161.   PINDEX length = 0;
  1162.   return length;
  1163. }
  1164.  
  1165.  
  1166. BOOL MCS_AUrq::Decode(PASN_Stream & strm)
  1167. {
  1168.   if (!PreambleDecode(strm))
  1169.     return FALSE;
  1170.  
  1171.  
  1172.   return UnknownExtensionsDecode(strm);
  1173. }
  1174.  
  1175.  
  1176. void MCS_AUrq::Encode(PASN_Stream & strm) const
  1177. {
  1178.   PreambleEncode(strm);
  1179.  
  1180.  
  1181.   UnknownExtensionsEncode(strm);
  1182. }
  1183.  
  1184.  
  1185. PObject * MCS_AUrq::Clone() const
  1186. {
  1187. #ifndef PASN_LEANANDMEAN
  1188.   PAssert(IsClass(MCS_AUrq::Class()), PInvalidCast);
  1189. #endif
  1190.   return new MCS_AUrq(*this);
  1191. }
  1192.  
  1193.  
  1194. //
  1195. // CJrq
  1196. //
  1197.  
  1198. MCS_CJrq::MCS_CJrq(unsigned tag, PASN_Object::TagClass tagClass)
  1199.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1200. {
  1201. }
  1202.  
  1203.  
  1204. #ifndef PASN_NOPRINTON
  1205. void MCS_CJrq::PrintOn(ostream & strm) const
  1206. {
  1207.   int indent = strm.precision() + 2;
  1208.   strm << "{\n";
  1209.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  1210.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  1211.   strm << setw(indent-1) << "}";
  1212. }
  1213. #endif
  1214.  
  1215.  
  1216. PObject::Comparison MCS_CJrq::Compare(const PObject & obj) const
  1217. {
  1218. #ifndef PASN_LEANANDMEAN
  1219.   PAssert(IsDescendant(MCS_CJrq::Class()), PInvalidCast);
  1220. #endif
  1221.   const MCS_CJrq & other = (const MCS_CJrq &)obj;
  1222.  
  1223.   Comparison result;
  1224.  
  1225.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  1226.     return result;
  1227.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  1228.     return result;
  1229.  
  1230.   return PASN_Sequence::Compare(other);
  1231. }
  1232.  
  1233.  
  1234. PINDEX MCS_CJrq::GetDataLength() const
  1235. {
  1236.   PINDEX length = 0;
  1237.   length += m_initiator.GetObjectLength();
  1238.   length += m_channelId.GetObjectLength();
  1239.   return length;
  1240. }
  1241.  
  1242.  
  1243. BOOL MCS_CJrq::Decode(PASN_Stream & strm)
  1244. {
  1245.   if (!PreambleDecode(strm))
  1246.     return FALSE;
  1247.  
  1248.   if (!m_initiator.Decode(strm))
  1249.     return FALSE;
  1250.   if (!m_channelId.Decode(strm))
  1251.     return FALSE;
  1252.  
  1253.   return UnknownExtensionsDecode(strm);
  1254. }
  1255.  
  1256.  
  1257. void MCS_CJrq::Encode(PASN_Stream & strm) const
  1258. {
  1259.   PreambleEncode(strm);
  1260.  
  1261.   m_initiator.Encode(strm);
  1262.   m_channelId.Encode(strm);
  1263.  
  1264.   UnknownExtensionsEncode(strm);
  1265. }
  1266.  
  1267.  
  1268. PObject * MCS_CJrq::Clone() const
  1269. {
  1270. #ifndef PASN_LEANANDMEAN
  1271.   PAssert(IsClass(MCS_CJrq::Class()), PInvalidCast);
  1272. #endif
  1273.   return new MCS_CJrq(*this);
  1274. }
  1275.  
  1276.  
  1277. //
  1278. // CCrq
  1279. //
  1280.  
  1281. MCS_CCrq::MCS_CCrq(unsigned tag, PASN_Object::TagClass tagClass)
  1282.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1283. {
  1284. }
  1285.  
  1286.  
  1287. #ifndef PASN_NOPRINTON
  1288. void MCS_CCrq::PrintOn(ostream & strm) const
  1289. {
  1290.   int indent = strm.precision() + 2;
  1291.   strm << "{\n";
  1292.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  1293.   strm << setw(indent-1) << "}";
  1294. }
  1295. #endif
  1296.  
  1297.  
  1298. PObject::Comparison MCS_CCrq::Compare(const PObject & obj) const
  1299. {
  1300. #ifndef PASN_LEANANDMEAN
  1301.   PAssert(IsDescendant(MCS_CCrq::Class()), PInvalidCast);
  1302. #endif
  1303.   const MCS_CCrq & other = (const MCS_CCrq &)obj;
  1304.  
  1305.   Comparison result;
  1306.  
  1307.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  1308.     return result;
  1309.  
  1310.   return PASN_Sequence::Compare(other);
  1311. }
  1312.  
  1313.  
  1314. PINDEX MCS_CCrq::GetDataLength() const
  1315. {
  1316.   PINDEX length = 0;
  1317.   length += m_initiator.GetObjectLength();
  1318.   return length;
  1319. }
  1320.  
  1321.  
  1322. BOOL MCS_CCrq::Decode(PASN_Stream & strm)
  1323. {
  1324.   if (!PreambleDecode(strm))
  1325.     return FALSE;
  1326.  
  1327.   if (!m_initiator.Decode(strm))
  1328.     return FALSE;
  1329.  
  1330.   return UnknownExtensionsDecode(strm);
  1331. }
  1332.  
  1333.  
  1334. void MCS_CCrq::Encode(PASN_Stream & strm) const
  1335. {
  1336.   PreambleEncode(strm);
  1337.  
  1338.   m_initiator.Encode(strm);
  1339.  
  1340.   UnknownExtensionsEncode(strm);
  1341. }
  1342.  
  1343.  
  1344. PObject * MCS_CCrq::Clone() const
  1345. {
  1346. #ifndef PASN_LEANANDMEAN
  1347.   PAssert(IsClass(MCS_CCrq::Class()), PInvalidCast);
  1348. #endif
  1349.   return new MCS_CCrq(*this);
  1350. }
  1351.  
  1352.  
  1353. //
  1354. // CDrq
  1355. //
  1356.  
  1357. MCS_CDrq::MCS_CDrq(unsigned tag, PASN_Object::TagClass tagClass)
  1358.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1359. {
  1360. }
  1361.  
  1362.  
  1363. #ifndef PASN_NOPRINTON
  1364. void MCS_CDrq::PrintOn(ostream & strm) const
  1365. {
  1366.   int indent = strm.precision() + 2;
  1367.   strm << "{\n";
  1368.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  1369.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  1370.   strm << setw(indent-1) << "}";
  1371. }
  1372. #endif
  1373.  
  1374.  
  1375. PObject::Comparison MCS_CDrq::Compare(const PObject & obj) const
  1376. {
  1377. #ifndef PASN_LEANANDMEAN
  1378.   PAssert(IsDescendant(MCS_CDrq::Class()), PInvalidCast);
  1379. #endif
  1380.   const MCS_CDrq & other = (const MCS_CDrq &)obj;
  1381.  
  1382.   Comparison result;
  1383.  
  1384.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  1385.     return result;
  1386.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  1387.     return result;
  1388.  
  1389.   return PASN_Sequence::Compare(other);
  1390. }
  1391.  
  1392.  
  1393. PINDEX MCS_CDrq::GetDataLength() const
  1394. {
  1395.   PINDEX length = 0;
  1396.   length += m_initiator.GetObjectLength();
  1397.   length += m_channelId.GetObjectLength();
  1398.   return length;
  1399. }
  1400.  
  1401.  
  1402. BOOL MCS_CDrq::Decode(PASN_Stream & strm)
  1403. {
  1404.   if (!PreambleDecode(strm))
  1405.     return FALSE;
  1406.  
  1407.   if (!m_initiator.Decode(strm))
  1408.     return FALSE;
  1409.   if (!m_channelId.Decode(strm))
  1410.     return FALSE;
  1411.  
  1412.   return UnknownExtensionsDecode(strm);
  1413. }
  1414.  
  1415.  
  1416. void MCS_CDrq::Encode(PASN_Stream & strm) const
  1417. {
  1418.   PreambleEncode(strm);
  1419.  
  1420.   m_initiator.Encode(strm);
  1421.   m_channelId.Encode(strm);
  1422.  
  1423.   UnknownExtensionsEncode(strm);
  1424. }
  1425.  
  1426.  
  1427. PObject * MCS_CDrq::Clone() const
  1428. {
  1429. #ifndef PASN_LEANANDMEAN
  1430.   PAssert(IsClass(MCS_CDrq::Class()), PInvalidCast);
  1431. #endif
  1432.   return new MCS_CDrq(*this);
  1433. }
  1434.  
  1435.  
  1436. //
  1437. // CDin
  1438. //
  1439.  
  1440. MCS_CDin::MCS_CDin(unsigned tag, PASN_Object::TagClass tagClass)
  1441.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1442. {
  1443. }
  1444.  
  1445.  
  1446. #ifndef PASN_NOPRINTON
  1447. void MCS_CDin::PrintOn(ostream & strm) const
  1448. {
  1449.   int indent = strm.precision() + 2;
  1450.   strm << "{\n";
  1451.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  1452.   strm << setw(indent-1) << "}";
  1453. }
  1454. #endif
  1455.  
  1456.  
  1457. PObject::Comparison MCS_CDin::Compare(const PObject & obj) const
  1458. {
  1459. #ifndef PASN_LEANANDMEAN
  1460.   PAssert(IsDescendant(MCS_CDin::Class()), PInvalidCast);
  1461. #endif
  1462.   const MCS_CDin & other = (const MCS_CDin &)obj;
  1463.  
  1464.   Comparison result;
  1465.  
  1466.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  1467.     return result;
  1468.  
  1469.   return PASN_Sequence::Compare(other);
  1470. }
  1471.  
  1472.  
  1473. PINDEX MCS_CDin::GetDataLength() const
  1474. {
  1475.   PINDEX length = 0;
  1476.   length += m_channelId.GetObjectLength();
  1477.   return length;
  1478. }
  1479.  
  1480.  
  1481. BOOL MCS_CDin::Decode(PASN_Stream & strm)
  1482. {
  1483.   if (!PreambleDecode(strm))
  1484.     return FALSE;
  1485.  
  1486.   if (!m_channelId.Decode(strm))
  1487.     return FALSE;
  1488.  
  1489.   return UnknownExtensionsDecode(strm);
  1490. }
  1491.  
  1492.  
  1493. void MCS_CDin::Encode(PASN_Stream & strm) const
  1494. {
  1495.   PreambleEncode(strm);
  1496.  
  1497.   m_channelId.Encode(strm);
  1498.  
  1499.   UnknownExtensionsEncode(strm);
  1500. }
  1501.  
  1502.  
  1503. PObject * MCS_CDin::Clone() const
  1504. {
  1505. #ifndef PASN_LEANANDMEAN
  1506.   PAssert(IsClass(MCS_CDin::Class()), PInvalidCast);
  1507. #endif
  1508.   return new MCS_CDin(*this);
  1509. }
  1510.  
  1511.  
  1512. //
  1513. // SDrq
  1514. //
  1515.  
  1516. MCS_SDrq::MCS_SDrq(unsigned tag, PASN_Object::TagClass tagClass)
  1517.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1518. {
  1519. }
  1520.  
  1521.  
  1522. #ifndef PASN_NOPRINTON
  1523. void MCS_SDrq::PrintOn(ostream & strm) const
  1524. {
  1525.   int indent = strm.precision() + 2;
  1526.   strm << "{\n";
  1527.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  1528.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  1529.   strm << setw(indent+15) << "dataPriority = " << setprecision(indent) << m_dataPriority << '\n';
  1530.   strm << setw(indent+15) << "segmentation = " << setprecision(indent) << m_segmentation << '\n';
  1531.   strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  1532.   strm << setw(indent-1) << "}";
  1533. }
  1534. #endif
  1535.  
  1536.  
  1537. PObject::Comparison MCS_SDrq::Compare(const PObject & obj) const
  1538. {
  1539. #ifndef PASN_LEANANDMEAN
  1540.   PAssert(IsDescendant(MCS_SDrq::Class()), PInvalidCast);
  1541. #endif
  1542.   const MCS_SDrq & other = (const MCS_SDrq &)obj;
  1543.  
  1544.   Comparison result;
  1545.  
  1546.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  1547.     return result;
  1548.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  1549.     return result;
  1550.   if ((result = m_dataPriority.Compare(other.m_dataPriority)) != EqualTo)
  1551.     return result;
  1552.   if ((result = m_segmentation.Compare(other.m_segmentation)) != EqualTo)
  1553.     return result;
  1554.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  1555.     return result;
  1556.  
  1557.   return PASN_Sequence::Compare(other);
  1558. }
  1559.  
  1560.  
  1561. PINDEX MCS_SDrq::GetDataLength() const
  1562. {
  1563.   PINDEX length = 0;
  1564.   length += m_initiator.GetObjectLength();
  1565.   length += m_channelId.GetObjectLength();
  1566.   length += m_dataPriority.GetObjectLength();
  1567.   length += m_segmentation.GetObjectLength();
  1568.   length += m_userData.GetObjectLength();
  1569.   return length;
  1570. }
  1571.  
  1572.  
  1573. BOOL MCS_SDrq::Decode(PASN_Stream & strm)
  1574. {
  1575.   if (!PreambleDecode(strm))
  1576.     return FALSE;
  1577.  
  1578.   if (!m_initiator.Decode(strm))
  1579.     return FALSE;
  1580.   if (!m_channelId.Decode(strm))
  1581.     return FALSE;
  1582.   if (!m_dataPriority.Decode(strm))
  1583.     return FALSE;
  1584.   if (!m_segmentation.Decode(strm))
  1585.     return FALSE;
  1586.   if (!m_userData.Decode(strm))
  1587.     return FALSE;
  1588.  
  1589.   return UnknownExtensionsDecode(strm);
  1590. }
  1591.  
  1592.  
  1593. void MCS_SDrq::Encode(PASN_Stream & strm) const
  1594. {
  1595.   PreambleEncode(strm);
  1596.  
  1597.   m_initiator.Encode(strm);
  1598.   m_channelId.Encode(strm);
  1599.   m_dataPriority.Encode(strm);
  1600.   m_segmentation.Encode(strm);
  1601.   m_userData.Encode(strm);
  1602.  
  1603.   UnknownExtensionsEncode(strm);
  1604. }
  1605.  
  1606.  
  1607. PObject * MCS_SDrq::Clone() const
  1608. {
  1609. #ifndef PASN_LEANANDMEAN
  1610.   PAssert(IsClass(MCS_SDrq::Class()), PInvalidCast);
  1611. #endif
  1612.   return new MCS_SDrq(*this);
  1613. }
  1614.  
  1615.  
  1616. //
  1617. // SDin
  1618. //
  1619.  
  1620. MCS_SDin::MCS_SDin(unsigned tag, PASN_Object::TagClass tagClass)
  1621.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1622. {
  1623. }
  1624.  
  1625.  
  1626. #ifndef PASN_NOPRINTON
  1627. void MCS_SDin::PrintOn(ostream & strm) const
  1628. {
  1629.   int indent = strm.precision() + 2;
  1630.   strm << "{\n";
  1631.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  1632.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  1633.   strm << setw(indent+15) << "dataPriority = " << setprecision(indent) << m_dataPriority << '\n';
  1634.   strm << setw(indent+15) << "segmentation = " << setprecision(indent) << m_segmentation << '\n';
  1635.   strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  1636.   strm << setw(indent-1) << "}";
  1637. }
  1638. #endif
  1639.  
  1640.  
  1641. PObject::Comparison MCS_SDin::Compare(const PObject & obj) const
  1642. {
  1643. #ifndef PASN_LEANANDMEAN
  1644.   PAssert(IsDescendant(MCS_SDin::Class()), PInvalidCast);
  1645. #endif
  1646.   const MCS_SDin & other = (const MCS_SDin &)obj;
  1647.  
  1648.   Comparison result;
  1649.  
  1650.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  1651.     return result;
  1652.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  1653.     return result;
  1654.   if ((result = m_dataPriority.Compare(other.m_dataPriority)) != EqualTo)
  1655.     return result;
  1656.   if ((result = m_segmentation.Compare(other.m_segmentation)) != EqualTo)
  1657.     return result;
  1658.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  1659.     return result;
  1660.  
  1661.   return PASN_Sequence::Compare(other);
  1662. }
  1663.  
  1664.  
  1665. PINDEX MCS_SDin::GetDataLength() const
  1666. {
  1667.   PINDEX length = 0;
  1668.   length += m_initiator.GetObjectLength();
  1669.   length += m_channelId.GetObjectLength();
  1670.   length += m_dataPriority.GetObjectLength();
  1671.   length += m_segmentation.GetObjectLength();
  1672.   length += m_userData.GetObjectLength();
  1673.   return length;
  1674. }
  1675.  
  1676.  
  1677. BOOL MCS_SDin::Decode(PASN_Stream & strm)
  1678. {
  1679.   if (!PreambleDecode(strm))
  1680.     return FALSE;
  1681.  
  1682.   if (!m_initiator.Decode(strm))
  1683.     return FALSE;
  1684.   if (!m_channelId.Decode(strm))
  1685.     return FALSE;
  1686.   if (!m_dataPriority.Decode(strm))
  1687.     return FALSE;
  1688.   if (!m_segmentation.Decode(strm))
  1689.     return FALSE;
  1690.   if (!m_userData.Decode(strm))
  1691.     return FALSE;
  1692.  
  1693.   return UnknownExtensionsDecode(strm);
  1694. }
  1695.  
  1696.  
  1697. void MCS_SDin::Encode(PASN_Stream & strm) const
  1698. {
  1699.   PreambleEncode(strm);
  1700.  
  1701.   m_initiator.Encode(strm);
  1702.   m_channelId.Encode(strm);
  1703.   m_dataPriority.Encode(strm);
  1704.   m_segmentation.Encode(strm);
  1705.   m_userData.Encode(strm);
  1706.  
  1707.   UnknownExtensionsEncode(strm);
  1708. }
  1709.  
  1710.  
  1711. PObject * MCS_SDin::Clone() const
  1712. {
  1713. #ifndef PASN_LEANANDMEAN
  1714.   PAssert(IsClass(MCS_SDin::Class()), PInvalidCast);
  1715. #endif
  1716.   return new MCS_SDin(*this);
  1717. }
  1718.  
  1719.  
  1720. //
  1721. // USrq
  1722. //
  1723.  
  1724. MCS_USrq::MCS_USrq(unsigned tag, PASN_Object::TagClass tagClass)
  1725.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1726. {
  1727. }
  1728.  
  1729.  
  1730. #ifndef PASN_NOPRINTON
  1731. void MCS_USrq::PrintOn(ostream & strm) const
  1732. {
  1733.   int indent = strm.precision() + 2;
  1734.   strm << "{\n";
  1735.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  1736.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  1737.   strm << setw(indent+15) << "dataPriority = " << setprecision(indent) << m_dataPriority << '\n';
  1738.   strm << setw(indent+15) << "segmentation = " << setprecision(indent) << m_segmentation << '\n';
  1739.   strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  1740.   strm << setw(indent-1) << "}";
  1741. }
  1742. #endif
  1743.  
  1744.  
  1745. PObject::Comparison MCS_USrq::Compare(const PObject & obj) const
  1746. {
  1747. #ifndef PASN_LEANANDMEAN
  1748.   PAssert(IsDescendant(MCS_USrq::Class()), PInvalidCast);
  1749. #endif
  1750.   const MCS_USrq & other = (const MCS_USrq &)obj;
  1751.  
  1752.   Comparison result;
  1753.  
  1754.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  1755.     return result;
  1756.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  1757.     return result;
  1758.   if ((result = m_dataPriority.Compare(other.m_dataPriority)) != EqualTo)
  1759.     return result;
  1760.   if ((result = m_segmentation.Compare(other.m_segmentation)) != EqualTo)
  1761.     return result;
  1762.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  1763.     return result;
  1764.  
  1765.   return PASN_Sequence::Compare(other);
  1766. }
  1767.  
  1768.  
  1769. PINDEX MCS_USrq::GetDataLength() const
  1770. {
  1771.   PINDEX length = 0;
  1772.   length += m_initiator.GetObjectLength();
  1773.   length += m_channelId.GetObjectLength();
  1774.   length += m_dataPriority.GetObjectLength();
  1775.   length += m_segmentation.GetObjectLength();
  1776.   length += m_userData.GetObjectLength();
  1777.   return length;
  1778. }
  1779.  
  1780.  
  1781. BOOL MCS_USrq::Decode(PASN_Stream & strm)
  1782. {
  1783.   if (!PreambleDecode(strm))
  1784.     return FALSE;
  1785.  
  1786.   if (!m_initiator.Decode(strm))
  1787.     return FALSE;
  1788.   if (!m_channelId.Decode(strm))
  1789.     return FALSE;
  1790.   if (!m_dataPriority.Decode(strm))
  1791.     return FALSE;
  1792.   if (!m_segmentation.Decode(strm))
  1793.     return FALSE;
  1794.   if (!m_userData.Decode(strm))
  1795.     return FALSE;
  1796.  
  1797.   return UnknownExtensionsDecode(strm);
  1798. }
  1799.  
  1800.  
  1801. void MCS_USrq::Encode(PASN_Stream & strm) const
  1802. {
  1803.   PreambleEncode(strm);
  1804.  
  1805.   m_initiator.Encode(strm);
  1806.   m_channelId.Encode(strm);
  1807.   m_dataPriority.Encode(strm);
  1808.   m_segmentation.Encode(strm);
  1809.   m_userData.Encode(strm);
  1810.  
  1811.   UnknownExtensionsEncode(strm);
  1812. }
  1813.  
  1814.  
  1815. PObject * MCS_USrq::Clone() const
  1816. {
  1817. #ifndef PASN_LEANANDMEAN
  1818.   PAssert(IsClass(MCS_USrq::Class()), PInvalidCast);
  1819. #endif
  1820.   return new MCS_USrq(*this);
  1821. }
  1822.  
  1823.  
  1824. //
  1825. // USin
  1826. //
  1827.  
  1828. MCS_USin::MCS_USin(unsigned tag, PASN_Object::TagClass tagClass)
  1829.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1830. {
  1831. }
  1832.  
  1833.  
  1834. #ifndef PASN_NOPRINTON
  1835. void MCS_USin::PrintOn(ostream & strm) const
  1836. {
  1837.   int indent = strm.precision() + 2;
  1838.   strm << "{\n";
  1839.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  1840.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  1841.   strm << setw(indent+15) << "dataPriority = " << setprecision(indent) << m_dataPriority << '\n';
  1842.   strm << setw(indent+15) << "segmentation = " << setprecision(indent) << m_segmentation << '\n';
  1843.   strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  1844.   strm << setw(indent-1) << "}";
  1845. }
  1846. #endif
  1847.  
  1848.  
  1849. PObject::Comparison MCS_USin::Compare(const PObject & obj) const
  1850. {
  1851. #ifndef PASN_LEANANDMEAN
  1852.   PAssert(IsDescendant(MCS_USin::Class()), PInvalidCast);
  1853. #endif
  1854.   const MCS_USin & other = (const MCS_USin &)obj;
  1855.  
  1856.   Comparison result;
  1857.  
  1858.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  1859.     return result;
  1860.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  1861.     return result;
  1862.   if ((result = m_dataPriority.Compare(other.m_dataPriority)) != EqualTo)
  1863.     return result;
  1864.   if ((result = m_segmentation.Compare(other.m_segmentation)) != EqualTo)
  1865.     return result;
  1866.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  1867.     return result;
  1868.  
  1869.   return PASN_Sequence::Compare(other);
  1870. }
  1871.  
  1872.  
  1873. PINDEX MCS_USin::GetDataLength() const
  1874. {
  1875.   PINDEX length = 0;
  1876.   length += m_initiator.GetObjectLength();
  1877.   length += m_channelId.GetObjectLength();
  1878.   length += m_dataPriority.GetObjectLength();
  1879.   length += m_segmentation.GetObjectLength();
  1880.   length += m_userData.GetObjectLength();
  1881.   return length;
  1882. }
  1883.  
  1884.  
  1885. BOOL MCS_USin::Decode(PASN_Stream & strm)
  1886. {
  1887.   if (!PreambleDecode(strm))
  1888.     return FALSE;
  1889.  
  1890.   if (!m_initiator.Decode(strm))
  1891.     return FALSE;
  1892.   if (!m_channelId.Decode(strm))
  1893.     return FALSE;
  1894.   if (!m_dataPriority.Decode(strm))
  1895.     return FALSE;
  1896.   if (!m_segmentation.Decode(strm))
  1897.     return FALSE;
  1898.   if (!m_userData.Decode(strm))
  1899.     return FALSE;
  1900.  
  1901.   return UnknownExtensionsDecode(strm);
  1902. }
  1903.  
  1904.  
  1905. void MCS_USin::Encode(PASN_Stream & strm) const
  1906. {
  1907.   PreambleEncode(strm);
  1908.  
  1909.   m_initiator.Encode(strm);
  1910.   m_channelId.Encode(strm);
  1911.   m_dataPriority.Encode(strm);
  1912.   m_segmentation.Encode(strm);
  1913.   m_userData.Encode(strm);
  1914.  
  1915.   UnknownExtensionsEncode(strm);
  1916. }
  1917.  
  1918.  
  1919. PObject * MCS_USin::Clone() const
  1920. {
  1921. #ifndef PASN_LEANANDMEAN
  1922.   PAssert(IsClass(MCS_USin::Class()), PInvalidCast);
  1923. #endif
  1924.   return new MCS_USin(*this);
  1925. }
  1926.  
  1927.  
  1928. //
  1929. // TGrq
  1930. //
  1931.  
  1932. MCS_TGrq::MCS_TGrq(unsigned tag, PASN_Object::TagClass tagClass)
  1933.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  1934. {
  1935. }
  1936.  
  1937.  
  1938. #ifndef PASN_NOPRINTON
  1939. void MCS_TGrq::PrintOn(ostream & strm) const
  1940. {
  1941.   int indent = strm.precision() + 2;
  1942.   strm << "{\n";
  1943.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  1944.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  1945.   strm << setw(indent-1) << "}";
  1946. }
  1947. #endif
  1948.  
  1949.  
  1950. PObject::Comparison MCS_TGrq::Compare(const PObject & obj) const
  1951. {
  1952. #ifndef PASN_LEANANDMEAN
  1953.   PAssert(IsDescendant(MCS_TGrq::Class()), PInvalidCast);
  1954. #endif
  1955.   const MCS_TGrq & other = (const MCS_TGrq &)obj;
  1956.  
  1957.   Comparison result;
  1958.  
  1959.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  1960.     return result;
  1961.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  1962.     return result;
  1963.  
  1964.   return PASN_Sequence::Compare(other);
  1965. }
  1966.  
  1967.  
  1968. PINDEX MCS_TGrq::GetDataLength() const
  1969. {
  1970.   PINDEX length = 0;
  1971.   length += m_initiator.GetObjectLength();
  1972.   length += m_tokenId.GetObjectLength();
  1973.   return length;
  1974. }
  1975.  
  1976.  
  1977. BOOL MCS_TGrq::Decode(PASN_Stream & strm)
  1978. {
  1979.   if (!PreambleDecode(strm))
  1980.     return FALSE;
  1981.  
  1982.   if (!m_initiator.Decode(strm))
  1983.     return FALSE;
  1984.   if (!m_tokenId.Decode(strm))
  1985.     return FALSE;
  1986.  
  1987.   return UnknownExtensionsDecode(strm);
  1988. }
  1989.  
  1990.  
  1991. void MCS_TGrq::Encode(PASN_Stream & strm) const
  1992. {
  1993.   PreambleEncode(strm);
  1994.  
  1995.   m_initiator.Encode(strm);
  1996.   m_tokenId.Encode(strm);
  1997.  
  1998.   UnknownExtensionsEncode(strm);
  1999. }
  2000.  
  2001.  
  2002. PObject * MCS_TGrq::Clone() const
  2003. {
  2004. #ifndef PASN_LEANANDMEAN
  2005.   PAssert(IsClass(MCS_TGrq::Class()), PInvalidCast);
  2006. #endif
  2007.   return new MCS_TGrq(*this);
  2008. }
  2009.  
  2010.  
  2011. //
  2012. // TIrq
  2013. //
  2014.  
  2015. MCS_TIrq::MCS_TIrq(unsigned tag, PASN_Object::TagClass tagClass)
  2016.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  2017. {
  2018. }
  2019.  
  2020.  
  2021. #ifndef PASN_NOPRINTON
  2022. void MCS_TIrq::PrintOn(ostream & strm) const
  2023. {
  2024.   int indent = strm.precision() + 2;
  2025.   strm << "{\n";
  2026.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  2027.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  2028.   strm << setw(indent-1) << "}";
  2029. }
  2030. #endif
  2031.  
  2032.  
  2033. PObject::Comparison MCS_TIrq::Compare(const PObject & obj) const
  2034. {
  2035. #ifndef PASN_LEANANDMEAN
  2036.   PAssert(IsDescendant(MCS_TIrq::Class()), PInvalidCast);
  2037. #endif
  2038.   const MCS_TIrq & other = (const MCS_TIrq &)obj;
  2039.  
  2040.   Comparison result;
  2041.  
  2042.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  2043.     return result;
  2044.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  2045.     return result;
  2046.  
  2047.   return PASN_Sequence::Compare(other);
  2048. }
  2049.  
  2050.  
  2051. PINDEX MCS_TIrq::GetDataLength() const
  2052. {
  2053.   PINDEX length = 0;
  2054.   length += m_initiator.GetObjectLength();
  2055.   length += m_tokenId.GetObjectLength();
  2056.   return length;
  2057. }
  2058.  
  2059.  
  2060. BOOL MCS_TIrq::Decode(PASN_Stream & strm)
  2061. {
  2062.   if (!PreambleDecode(strm))
  2063.     return FALSE;
  2064.  
  2065.   if (!m_initiator.Decode(strm))
  2066.     return FALSE;
  2067.   if (!m_tokenId.Decode(strm))
  2068.     return FALSE;
  2069.  
  2070.   return UnknownExtensionsDecode(strm);
  2071. }
  2072.  
  2073.  
  2074. void MCS_TIrq::Encode(PASN_Stream & strm) const
  2075. {
  2076.   PreambleEncode(strm);
  2077.  
  2078.   m_initiator.Encode(strm);
  2079.   m_tokenId.Encode(strm);
  2080.  
  2081.   UnknownExtensionsEncode(strm);
  2082. }
  2083.  
  2084.  
  2085. PObject * MCS_TIrq::Clone() const
  2086. {
  2087. #ifndef PASN_LEANANDMEAN
  2088.   PAssert(IsClass(MCS_TIrq::Class()), PInvalidCast);
  2089. #endif
  2090.   return new MCS_TIrq(*this);
  2091. }
  2092.  
  2093.  
  2094. //
  2095. // TVrq
  2096. //
  2097.  
  2098. MCS_TVrq::MCS_TVrq(unsigned tag, PASN_Object::TagClass tagClass)
  2099.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  2100. {
  2101. }
  2102.  
  2103.  
  2104. #ifndef PASN_NOPRINTON
  2105. void MCS_TVrq::PrintOn(ostream & strm) const
  2106. {
  2107.   int indent = strm.precision() + 2;
  2108.   strm << "{\n";
  2109.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  2110.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  2111.   strm << setw(indent+12) << "recipient = " << setprecision(indent) << m_recipient << '\n';
  2112.   strm << setw(indent-1) << "}";
  2113. }
  2114. #endif
  2115.  
  2116.  
  2117. PObject::Comparison MCS_TVrq::Compare(const PObject & obj) const
  2118. {
  2119. #ifndef PASN_LEANANDMEAN
  2120.   PAssert(IsDescendant(MCS_TVrq::Class()), PInvalidCast);
  2121. #endif
  2122.   const MCS_TVrq & other = (const MCS_TVrq &)obj;
  2123.  
  2124.   Comparison result;
  2125.  
  2126.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  2127.     return result;
  2128.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  2129.     return result;
  2130.   if ((result = m_recipient.Compare(other.m_recipient)) != EqualTo)
  2131.     return result;
  2132.  
  2133.   return PASN_Sequence::Compare(other);
  2134. }
  2135.  
  2136.  
  2137. PINDEX MCS_TVrq::GetDataLength() const
  2138. {
  2139.   PINDEX length = 0;
  2140.   length += m_initiator.GetObjectLength();
  2141.   length += m_tokenId.GetObjectLength();
  2142.   length += m_recipient.GetObjectLength();
  2143.   return length;
  2144. }
  2145.  
  2146.  
  2147. BOOL MCS_TVrq::Decode(PASN_Stream & strm)
  2148. {
  2149.   if (!PreambleDecode(strm))
  2150.     return FALSE;
  2151.  
  2152.   if (!m_initiator.Decode(strm))
  2153.     return FALSE;
  2154.   if (!m_tokenId.Decode(strm))
  2155.     return FALSE;
  2156.   if (!m_recipient.Decode(strm))
  2157.     return FALSE;
  2158.  
  2159.   return UnknownExtensionsDecode(strm);
  2160. }
  2161.  
  2162.  
  2163. void MCS_TVrq::Encode(PASN_Stream & strm) const
  2164. {
  2165.   PreambleEncode(strm);
  2166.  
  2167.   m_initiator.Encode(strm);
  2168.   m_tokenId.Encode(strm);
  2169.   m_recipient.Encode(strm);
  2170.  
  2171.   UnknownExtensionsEncode(strm);
  2172. }
  2173.  
  2174.  
  2175. PObject * MCS_TVrq::Clone() const
  2176. {
  2177. #ifndef PASN_LEANANDMEAN
  2178.   PAssert(IsClass(MCS_TVrq::Class()), PInvalidCast);
  2179. #endif
  2180.   return new MCS_TVrq(*this);
  2181. }
  2182.  
  2183.  
  2184. //
  2185. // TVin
  2186. //
  2187.  
  2188. MCS_TVin::MCS_TVin(unsigned tag, PASN_Object::TagClass tagClass)
  2189.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  2190. {
  2191. }
  2192.  
  2193.  
  2194. #ifndef PASN_NOPRINTON
  2195. void MCS_TVin::PrintOn(ostream & strm) const
  2196. {
  2197.   int indent = strm.precision() + 2;
  2198.   strm << "{\n";
  2199.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  2200.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  2201.   strm << setw(indent+12) << "recipient = " << setprecision(indent) << m_recipient << '\n';
  2202.   strm << setw(indent-1) << "}";
  2203. }
  2204. #endif
  2205.  
  2206.  
  2207. PObject::Comparison MCS_TVin::Compare(const PObject & obj) const
  2208. {
  2209. #ifndef PASN_LEANANDMEAN
  2210.   PAssert(IsDescendant(MCS_TVin::Class()), PInvalidCast);
  2211. #endif
  2212.   const MCS_TVin & other = (const MCS_TVin &)obj;
  2213.  
  2214.   Comparison result;
  2215.  
  2216.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  2217.     return result;
  2218.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  2219.     return result;
  2220.   if ((result = m_recipient.Compare(other.m_recipient)) != EqualTo)
  2221.     return result;
  2222.  
  2223.   return PASN_Sequence::Compare(other);
  2224. }
  2225.  
  2226.  
  2227. PINDEX MCS_TVin::GetDataLength() const
  2228. {
  2229.   PINDEX length = 0;
  2230.   length += m_initiator.GetObjectLength();
  2231.   length += m_tokenId.GetObjectLength();
  2232.   length += m_recipient.GetObjectLength();
  2233.   return length;
  2234. }
  2235.  
  2236.  
  2237. BOOL MCS_TVin::Decode(PASN_Stream & strm)
  2238. {
  2239.   if (!PreambleDecode(strm))
  2240.     return FALSE;
  2241.  
  2242.   if (!m_initiator.Decode(strm))
  2243.     return FALSE;
  2244.   if (!m_tokenId.Decode(strm))
  2245.     return FALSE;
  2246.   if (!m_recipient.Decode(strm))
  2247.     return FALSE;
  2248.  
  2249.   return UnknownExtensionsDecode(strm);
  2250. }
  2251.  
  2252.  
  2253. void MCS_TVin::Encode(PASN_Stream & strm) const
  2254. {
  2255.   PreambleEncode(strm);
  2256.  
  2257.   m_initiator.Encode(strm);
  2258.   m_tokenId.Encode(strm);
  2259.   m_recipient.Encode(strm);
  2260.  
  2261.   UnknownExtensionsEncode(strm);
  2262. }
  2263.  
  2264.  
  2265. PObject * MCS_TVin::Clone() const
  2266. {
  2267. #ifndef PASN_LEANANDMEAN
  2268.   PAssert(IsClass(MCS_TVin::Class()), PInvalidCast);
  2269. #endif
  2270.   return new MCS_TVin(*this);
  2271. }
  2272.  
  2273.  
  2274. //
  2275. // TPrq
  2276. //
  2277.  
  2278. MCS_TPrq::MCS_TPrq(unsigned tag, PASN_Object::TagClass tagClass)
  2279.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  2280. {
  2281. }
  2282.  
  2283.  
  2284. #ifndef PASN_NOPRINTON
  2285. void MCS_TPrq::PrintOn(ostream & strm) const
  2286. {
  2287.   int indent = strm.precision() + 2;
  2288.   strm << "{\n";
  2289.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  2290.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  2291.   strm << setw(indent-1) << "}";
  2292. }
  2293. #endif
  2294.  
  2295.  
  2296. PObject::Comparison MCS_TPrq::Compare(const PObject & obj) const
  2297. {
  2298. #ifndef PASN_LEANANDMEAN
  2299.   PAssert(IsDescendant(MCS_TPrq::Class()), PInvalidCast);
  2300. #endif
  2301.   const MCS_TPrq & other = (const MCS_TPrq &)obj;
  2302.  
  2303.   Comparison result;
  2304.  
  2305.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  2306.     return result;
  2307.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  2308.     return result;
  2309.  
  2310.   return PASN_Sequence::Compare(other);
  2311. }
  2312.  
  2313.  
  2314. PINDEX MCS_TPrq::GetDataLength() const
  2315. {
  2316.   PINDEX length = 0;
  2317.   length += m_initiator.GetObjectLength();
  2318.   length += m_tokenId.GetObjectLength();
  2319.   return length;
  2320. }
  2321.  
  2322.  
  2323. BOOL MCS_TPrq::Decode(PASN_Stream & strm)
  2324. {
  2325.   if (!PreambleDecode(strm))
  2326.     return FALSE;
  2327.  
  2328.   if (!m_initiator.Decode(strm))
  2329.     return FALSE;
  2330.   if (!m_tokenId.Decode(strm))
  2331.     return FALSE;
  2332.  
  2333.   return UnknownExtensionsDecode(strm);
  2334. }
  2335.  
  2336.  
  2337. void MCS_TPrq::Encode(PASN_Stream & strm) const
  2338. {
  2339.   PreambleEncode(strm);
  2340.  
  2341.   m_initiator.Encode(strm);
  2342.   m_tokenId.Encode(strm);
  2343.  
  2344.   UnknownExtensionsEncode(strm);
  2345. }
  2346.  
  2347.  
  2348. PObject * MCS_TPrq::Clone() const
  2349. {
  2350. #ifndef PASN_LEANANDMEAN
  2351.   PAssert(IsClass(MCS_TPrq::Class()), PInvalidCast);
  2352. #endif
  2353.   return new MCS_TPrq(*this);
  2354. }
  2355.  
  2356.  
  2357. //
  2358. // TPin
  2359. //
  2360.  
  2361. MCS_TPin::MCS_TPin(unsigned tag, PASN_Object::TagClass tagClass)
  2362.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  2363. {
  2364. }
  2365.  
  2366.  
  2367. #ifndef PASN_NOPRINTON
  2368. void MCS_TPin::PrintOn(ostream & strm) const
  2369. {
  2370.   int indent = strm.precision() + 2;
  2371.   strm << "{\n";
  2372.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  2373.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  2374.   strm << setw(indent-1) << "}";
  2375. }
  2376. #endif
  2377.  
  2378.  
  2379. PObject::Comparison MCS_TPin::Compare(const PObject & obj) const
  2380. {
  2381. #ifndef PASN_LEANANDMEAN
  2382.   PAssert(IsDescendant(MCS_TPin::Class()), PInvalidCast);
  2383. #endif
  2384.   const MCS_TPin & other = (const MCS_TPin &)obj;
  2385.  
  2386.   Comparison result;
  2387.  
  2388.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  2389.     return result;
  2390.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  2391.     return result;
  2392.  
  2393.   return PASN_Sequence::Compare(other);
  2394. }
  2395.  
  2396.  
  2397. PINDEX MCS_TPin::GetDataLength() const
  2398. {
  2399.   PINDEX length = 0;
  2400.   length += m_initiator.GetObjectLength();
  2401.   length += m_tokenId.GetObjectLength();
  2402.   return length;
  2403. }
  2404.  
  2405.  
  2406. BOOL MCS_TPin::Decode(PASN_Stream & strm)
  2407. {
  2408.   if (!PreambleDecode(strm))
  2409.     return FALSE;
  2410.  
  2411.   if (!m_initiator.Decode(strm))
  2412.     return FALSE;
  2413.   if (!m_tokenId.Decode(strm))
  2414.     return FALSE;
  2415.  
  2416.   return UnknownExtensionsDecode(strm);
  2417. }
  2418.  
  2419.  
  2420. void MCS_TPin::Encode(PASN_Stream & strm) const
  2421. {
  2422.   PreambleEncode(strm);
  2423.  
  2424.   m_initiator.Encode(strm);
  2425.   m_tokenId.Encode(strm);
  2426.  
  2427.   UnknownExtensionsEncode(strm);
  2428. }
  2429.  
  2430.  
  2431. PObject * MCS_TPin::Clone() const
  2432. {
  2433. #ifndef PASN_LEANANDMEAN
  2434.   PAssert(IsClass(MCS_TPin::Class()), PInvalidCast);
  2435. #endif
  2436.   return new MCS_TPin(*this);
  2437. }
  2438.  
  2439.  
  2440. //
  2441. // TRrq
  2442. //
  2443.  
  2444. MCS_TRrq::MCS_TRrq(unsigned tag, PASN_Object::TagClass tagClass)
  2445.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  2446. {
  2447. }
  2448.  
  2449.  
  2450. #ifndef PASN_NOPRINTON
  2451. void MCS_TRrq::PrintOn(ostream & strm) const
  2452. {
  2453.   int indent = strm.precision() + 2;
  2454.   strm << "{\n";
  2455.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  2456.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  2457.   strm << setw(indent-1) << "}";
  2458. }
  2459. #endif
  2460.  
  2461.  
  2462. PObject::Comparison MCS_TRrq::Compare(const PObject & obj) const
  2463. {
  2464. #ifndef PASN_LEANANDMEAN
  2465.   PAssert(IsDescendant(MCS_TRrq::Class()), PInvalidCast);
  2466. #endif
  2467.   const MCS_TRrq & other = (const MCS_TRrq &)obj;
  2468.  
  2469.   Comparison result;
  2470.  
  2471.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  2472.     return result;
  2473.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  2474.     return result;
  2475.  
  2476.   return PASN_Sequence::Compare(other);
  2477. }
  2478.  
  2479.  
  2480. PINDEX MCS_TRrq::GetDataLength() const
  2481. {
  2482.   PINDEX length = 0;
  2483.   length += m_initiator.GetObjectLength();
  2484.   length += m_tokenId.GetObjectLength();
  2485.   return length;
  2486. }
  2487.  
  2488.  
  2489. BOOL MCS_TRrq::Decode(PASN_Stream & strm)
  2490. {
  2491.   if (!PreambleDecode(strm))
  2492.     return FALSE;
  2493.  
  2494.   if (!m_initiator.Decode(strm))
  2495.     return FALSE;
  2496.   if (!m_tokenId.Decode(strm))
  2497.     return FALSE;
  2498.  
  2499.   return UnknownExtensionsDecode(strm);
  2500. }
  2501.  
  2502.  
  2503. void MCS_TRrq::Encode(PASN_Stream & strm) const
  2504. {
  2505.   PreambleEncode(strm);
  2506.  
  2507.   m_initiator.Encode(strm);
  2508.   m_tokenId.Encode(strm);
  2509.  
  2510.   UnknownExtensionsEncode(strm);
  2511. }
  2512.  
  2513.  
  2514. PObject * MCS_TRrq::Clone() const
  2515. {
  2516. #ifndef PASN_LEANANDMEAN
  2517.   PAssert(IsClass(MCS_TRrq::Class()), PInvalidCast);
  2518. #endif
  2519.   return new MCS_TRrq(*this);
  2520. }
  2521.  
  2522.  
  2523. //
  2524. // TTrq
  2525. //
  2526.  
  2527. MCS_TTrq::MCS_TTrq(unsigned tag, PASN_Object::TagClass tagClass)
  2528.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  2529. {
  2530. }
  2531.  
  2532.  
  2533. #ifndef PASN_NOPRINTON
  2534. void MCS_TTrq::PrintOn(ostream & strm) const
  2535. {
  2536.   int indent = strm.precision() + 2;
  2537.   strm << "{\n";
  2538.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  2539.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  2540.   strm << setw(indent-1) << "}";
  2541. }
  2542. #endif
  2543.  
  2544.  
  2545. PObject::Comparison MCS_TTrq::Compare(const PObject & obj) const
  2546. {
  2547. #ifndef PASN_LEANANDMEAN
  2548.   PAssert(IsDescendant(MCS_TTrq::Class()), PInvalidCast);
  2549. #endif
  2550.   const MCS_TTrq & other = (const MCS_TTrq &)obj;
  2551.  
  2552.   Comparison result;
  2553.  
  2554.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  2555.     return result;
  2556.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  2557.     return result;
  2558.  
  2559.   return PASN_Sequence::Compare(other);
  2560. }
  2561.  
  2562.  
  2563. PINDEX MCS_TTrq::GetDataLength() const
  2564. {
  2565.   PINDEX length = 0;
  2566.   length += m_initiator.GetObjectLength();
  2567.   length += m_tokenId.GetObjectLength();
  2568.   return length;
  2569. }
  2570.  
  2571.  
  2572. BOOL MCS_TTrq::Decode(PASN_Stream & strm)
  2573. {
  2574.   if (!PreambleDecode(strm))
  2575.     return FALSE;
  2576.  
  2577.   if (!m_initiator.Decode(strm))
  2578.     return FALSE;
  2579.   if (!m_tokenId.Decode(strm))
  2580.     return FALSE;
  2581.  
  2582.   return UnknownExtensionsDecode(strm);
  2583. }
  2584.  
  2585.  
  2586. void MCS_TTrq::Encode(PASN_Stream & strm) const
  2587. {
  2588.   PreambleEncode(strm);
  2589.  
  2590.   m_initiator.Encode(strm);
  2591.   m_tokenId.Encode(strm);
  2592.  
  2593.   UnknownExtensionsEncode(strm);
  2594. }
  2595.  
  2596.  
  2597. PObject * MCS_TTrq::Clone() const
  2598. {
  2599. #ifndef PASN_LEANANDMEAN
  2600.   PAssert(IsClass(MCS_TTrq::Class()), PInvalidCast);
  2601. #endif
  2602.   return new MCS_TTrq(*this);
  2603. }
  2604.  
  2605.  
  2606. //
  2607. // TTcf
  2608. //
  2609.  
  2610. MCS_TTcf::MCS_TTcf(unsigned tag, PASN_Object::TagClass tagClass)
  2611.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  2612. {
  2613. }
  2614.  
  2615.  
  2616. #ifndef PASN_NOPRINTON
  2617. void MCS_TTcf::PrintOn(ostream & strm) const
  2618. {
  2619.   int indent = strm.precision() + 2;
  2620.   strm << "{\n";
  2621.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  2622.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  2623.   strm << setw(indent+14) << "tokenStatus = " << setprecision(indent) << m_tokenStatus << '\n';
  2624.   strm << setw(indent-1) << "}";
  2625. }
  2626. #endif
  2627.  
  2628.  
  2629. PObject::Comparison MCS_TTcf::Compare(const PObject & obj) const
  2630. {
  2631. #ifndef PASN_LEANANDMEAN
  2632.   PAssert(IsDescendant(MCS_TTcf::Class()), PInvalidCast);
  2633. #endif
  2634.   const MCS_TTcf & other = (const MCS_TTcf &)obj;
  2635.  
  2636.   Comparison result;
  2637.  
  2638.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  2639.     return result;
  2640.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  2641.     return result;
  2642.   if ((result = m_tokenStatus.Compare(other.m_tokenStatus)) != EqualTo)
  2643.     return result;
  2644.  
  2645.   return PASN_Sequence::Compare(other);
  2646. }
  2647.  
  2648.  
  2649. PINDEX MCS_TTcf::GetDataLength() const
  2650. {
  2651.   PINDEX length = 0;
  2652.   length += m_initiator.GetObjectLength();
  2653.   length += m_tokenId.GetObjectLength();
  2654.   length += m_tokenStatus.GetObjectLength();
  2655.   return length;
  2656. }
  2657.  
  2658.  
  2659. BOOL MCS_TTcf::Decode(PASN_Stream & strm)
  2660. {
  2661.   if (!PreambleDecode(strm))
  2662.     return FALSE;
  2663.  
  2664.   if (!m_initiator.Decode(strm))
  2665.     return FALSE;
  2666.   if (!m_tokenId.Decode(strm))
  2667.     return FALSE;
  2668.   if (!m_tokenStatus.Decode(strm))
  2669.     return FALSE;
  2670.  
  2671.   return UnknownExtensionsDecode(strm);
  2672. }
  2673.  
  2674.  
  2675. void MCS_TTcf::Encode(PASN_Stream & strm) const
  2676. {
  2677.   PreambleEncode(strm);
  2678.  
  2679.   m_initiator.Encode(strm);
  2680.   m_tokenId.Encode(strm);
  2681.   m_tokenStatus.Encode(strm);
  2682.  
  2683.   UnknownExtensionsEncode(strm);
  2684. }
  2685.  
  2686.  
  2687. PObject * MCS_TTcf::Clone() const
  2688. {
  2689. #ifndef PASN_LEANANDMEAN
  2690.   PAssert(IsClass(MCS_TTcf::Class()), PInvalidCast);
  2691. #endif
  2692.   return new MCS_TTcf(*this);
  2693. }
  2694.  
  2695.  
  2696. //
  2697. // Reason
  2698. //
  2699.  
  2700. MCS_Reason::MCS_Reason(unsigned tag, PASN_Object::TagClass tagClass)
  2701.   : PASN_Enumeration(tag, tagClass, 4, FALSE
  2702. #ifndef PASN_NOPRINTON
  2703.       , "rn-domain-disconnected "
  2704.         "rn-provider-initiated "
  2705.         "rn-token-purged "
  2706.         "rn-user-requested "
  2707.         "rn-channel-purged "
  2708. #endif
  2709.     )
  2710. {
  2711. }
  2712.  
  2713.  
  2714. MCS_Reason & MCS_Reason::operator=(unsigned v)
  2715. {
  2716.   SetValue(v);
  2717.   return *this;
  2718. }
  2719.  
  2720.  
  2721. PObject * MCS_Reason::Clone() const
  2722. {
  2723. #ifndef PASN_LEANANDMEAN
  2724.   PAssert(IsClass(MCS_Reason::Class()), PInvalidCast);
  2725. #endif
  2726.   return new MCS_Reason(*this);
  2727. }
  2728.  
  2729.  
  2730. //
  2731. // Result
  2732. //
  2733.  
  2734. MCS_Result::MCS_Result(unsigned tag, PASN_Object::TagClass tagClass)
  2735.   : PASN_Enumeration(tag, tagClass, 15, FALSE
  2736. #ifndef PASN_NOPRINTON
  2737.       , "rt-successful "
  2738.         "rt-domain-merging "
  2739.         "rt-domain-not-hierarchical "
  2740.         "rt-no-such-channel "
  2741.         "rt-no-such-domain "
  2742.         "rt-no-such-user "
  2743.         "rt-not-admitted "
  2744.         "rt-other-user-id "
  2745.         "rt-parameters-unacceptable "
  2746.         "rt-token-not-available "
  2747.         "rt-token-not-possessed "
  2748.         "rt-too-many-channels "
  2749.         "rt-too-many-tokens "
  2750.         "rt-too-many-users "
  2751.         "rt-unspecified-failure "
  2752.         "rt-user-rejected "
  2753. #endif
  2754.     )
  2755. {
  2756. }
  2757.  
  2758.  
  2759. MCS_Result & MCS_Result::operator=(unsigned v)
  2760. {
  2761.   SetValue(v);
  2762.   return *this;
  2763. }
  2764.  
  2765.  
  2766. PObject * MCS_Result::Clone() const
  2767. {
  2768. #ifndef PASN_LEANANDMEAN
  2769.   PAssert(IsClass(MCS_Result::Class()), PInvalidCast);
  2770. #endif
  2771.   return new MCS_Result(*this);
  2772. }
  2773.  
  2774.  
  2775. //
  2776. // Diagnostic
  2777. //
  2778.  
  2779. MCS_Diagnostic::MCS_Diagnostic(unsigned tag, PASN_Object::TagClass tagClass)
  2780.   : PASN_Enumeration(tag, tagClass, 13, FALSE
  2781. #ifndef PASN_NOPRINTON
  2782.       , "dc-inconsistent-merge "
  2783.         "dc-forbidden-PDU-downward "
  2784.         "dc-forbidden-PDU-upward "
  2785.         "dc-invalid-BER-encoding "
  2786.         "dc-invalid-PER-encoding "
  2787.         "dc-misrouted-user "
  2788.         "dc-unrequested-confirm "
  2789.         "dc-wrong-transport-priority "
  2790.         "dc-channel-id-conflict "
  2791.         "dc-token-id-conflict "
  2792.         "dc-not-user-id-channel "
  2793.         "dc-too-many-channels "
  2794.         "dc-too-many-tokens "
  2795.         "dc-too-many-users "
  2796. #endif
  2797.     )
  2798. {
  2799. }
  2800.  
  2801.  
  2802. MCS_Diagnostic & MCS_Diagnostic::operator=(unsigned v)
  2803. {
  2804.   SetValue(v);
  2805.   return *this;
  2806. }
  2807.  
  2808.  
  2809. PObject * MCS_Diagnostic::Clone() const
  2810. {
  2811. #ifndef PASN_LEANANDMEAN
  2812.   PAssert(IsClass(MCS_Diagnostic::Class()), PInvalidCast);
  2813. #endif
  2814.   return new MCS_Diagnostic(*this);
  2815. }
  2816.  
  2817.  
  2818. //
  2819. // ConnectMCSPDU
  2820. //
  2821.  
  2822. MCS_ConnectMCSPDU::MCS_ConnectMCSPDU(unsigned tag, PASN_Object::TagClass tagClass)
  2823.   : PASN_Choice(tag, tagClass, 4, FALSE
  2824. #ifndef PASN_NOPRINTON
  2825.       , "connect_initial=101 "
  2826.         "connect_response "
  2827.         "connect_additional "
  2828.         "connect_result "
  2829. #endif
  2830.     )
  2831. {
  2832. }
  2833.  
  2834.  
  2835. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  2836. MCS_ConnectMCSPDU::operator MCS_Connect_Initial &() const
  2837. #else
  2838. MCS_ConnectMCSPDU::operator MCS_Connect_Initial &()
  2839. {
  2840. #ifndef PASN_LEANANDMEAN
  2841.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_Connect_Initial::Class()), PInvalidCast);
  2842. #endif
  2843.   return *(MCS_Connect_Initial *)choice;
  2844. }
  2845.  
  2846.  
  2847. MCS_ConnectMCSPDU::operator const MCS_Connect_Initial &() const
  2848. #endif
  2849. {
  2850. #ifndef PASN_LEANANDMEAN
  2851.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_Connect_Initial::Class()), PInvalidCast);
  2852. #endif
  2853.   return *(MCS_Connect_Initial *)choice;
  2854. }
  2855.  
  2856.  
  2857. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  2858. MCS_ConnectMCSPDU::operator MCS_Connect_Response &() const
  2859. #else
  2860. MCS_ConnectMCSPDU::operator MCS_Connect_Response &()
  2861. {
  2862. #ifndef PASN_LEANANDMEAN
  2863.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_Connect_Response::Class()), PInvalidCast);
  2864. #endif
  2865.   return *(MCS_Connect_Response *)choice;
  2866. }
  2867.  
  2868.  
  2869. MCS_ConnectMCSPDU::operator const MCS_Connect_Response &() const
  2870. #endif
  2871. {
  2872. #ifndef PASN_LEANANDMEAN
  2873.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_Connect_Response::Class()), PInvalidCast);
  2874. #endif
  2875.   return *(MCS_Connect_Response *)choice;
  2876. }
  2877.  
  2878.  
  2879. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  2880. MCS_ConnectMCSPDU::operator MCS_Connect_Additional &() const
  2881. #else
  2882. MCS_ConnectMCSPDU::operator MCS_Connect_Additional &()
  2883. {
  2884. #ifndef PASN_LEANANDMEAN
  2885.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_Connect_Additional::Class()), PInvalidCast);
  2886. #endif
  2887.   return *(MCS_Connect_Additional *)choice;
  2888. }
  2889.  
  2890.  
  2891. MCS_ConnectMCSPDU::operator const MCS_Connect_Additional &() const
  2892. #endif
  2893. {
  2894. #ifndef PASN_LEANANDMEAN
  2895.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_Connect_Additional::Class()), PInvalidCast);
  2896. #endif
  2897.   return *(MCS_Connect_Additional *)choice;
  2898. }
  2899.  
  2900.  
  2901. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  2902. MCS_ConnectMCSPDU::operator MCS_Connect_Result &() const
  2903. #else
  2904. MCS_ConnectMCSPDU::operator MCS_Connect_Result &()
  2905. {
  2906. #ifndef PASN_LEANANDMEAN
  2907.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_Connect_Result::Class()), PInvalidCast);
  2908. #endif
  2909.   return *(MCS_Connect_Result *)choice;
  2910. }
  2911.  
  2912.  
  2913. MCS_ConnectMCSPDU::operator const MCS_Connect_Result &() const
  2914. #endif
  2915. {
  2916. #ifndef PASN_LEANANDMEAN
  2917.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_Connect_Result::Class()), PInvalidCast);
  2918. #endif
  2919.   return *(MCS_Connect_Result *)choice;
  2920. }
  2921.  
  2922.  
  2923. BOOL MCS_ConnectMCSPDU::CreateObject()
  2924. {
  2925.   switch (tag) {
  2926.     case e_connect_initial :
  2927.       choice = new MCS_Connect_Initial();
  2928.       return TRUE;
  2929.     case e_connect_response :
  2930.       choice = new MCS_Connect_Response();
  2931.       return TRUE;
  2932.     case e_connect_additional :
  2933.       choice = new MCS_Connect_Additional();
  2934.       return TRUE;
  2935.     case e_connect_result :
  2936.       choice = new MCS_Connect_Result();
  2937.       return TRUE;
  2938.   }
  2939.  
  2940.   choice = NULL;
  2941.   return FALSE;
  2942. }
  2943.  
  2944.  
  2945. PObject * MCS_ConnectMCSPDU::Clone() const
  2946. {
  2947. #ifndef PASN_LEANANDMEAN
  2948.   PAssert(IsClass(MCS_ConnectMCSPDU::Class()), PInvalidCast);
  2949. #endif
  2950.   return new MCS_ConnectMCSPDU(*this);
  2951. }
  2952.  
  2953.  
  2954. //
  2955. // DomainMCSPDU
  2956. //
  2957.  
  2958. MCS_DomainMCSPDU::MCS_DomainMCSPDU(unsigned tag, PASN_Object::TagClass tagClass)
  2959.   : PASN_Choice(tag, tagClass, 43, FALSE
  2960. #ifndef PASN_NOPRINTON
  2961.       , "pdin "
  2962.         "edrq "
  2963.         "mcrq "
  2964.         "mccf "
  2965.         "pcin "
  2966.         "mtrq "
  2967.         "mtcf "
  2968.         "ptin "
  2969.         "dpum "
  2970.         "rjum "
  2971.         "aurq "
  2972.         "aucf "
  2973.         "durq "
  2974.         "duin "
  2975.         "cjrq "
  2976.         "cjcf "
  2977.         "clrq "
  2978.         "ccrq "
  2979.         "cccf "
  2980.         "cdrq "
  2981.         "cdin "
  2982.         "carq "
  2983.         "cain "
  2984.         "cerq "
  2985.         "cein "
  2986.         "sdrq "
  2987.         "sdin "
  2988.         "usrq "
  2989.         "usin "
  2990.         "tgrq "
  2991.         "tgcf "
  2992.         "tirq "
  2993.         "ticf "
  2994.         "tvrq "
  2995.         "tvin "
  2996.         "tvrs "
  2997.         "tvcf "
  2998.         "tprq "
  2999.         "tpin "
  3000.         "trrq "
  3001.         "trcf "
  3002.         "ttrq "
  3003.         "ttcf "
  3004. #endif
  3005.     )
  3006. {
  3007. }
  3008.  
  3009.  
  3010. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3011. MCS_DomainMCSPDU::operator MCS_PDin &() const
  3012. #else
  3013. MCS_DomainMCSPDU::operator MCS_PDin &()
  3014. {
  3015. #ifndef PASN_LEANANDMEAN
  3016.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_PDin::Class()), PInvalidCast);
  3017. #endif
  3018.   return *(MCS_PDin *)choice;
  3019. }
  3020.  
  3021.  
  3022. MCS_DomainMCSPDU::operator const MCS_PDin &() const
  3023. #endif
  3024. {
  3025. #ifndef PASN_LEANANDMEAN
  3026.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_PDin::Class()), PInvalidCast);
  3027. #endif
  3028.   return *(MCS_PDin *)choice;
  3029. }
  3030.  
  3031.  
  3032. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3033. MCS_DomainMCSPDU::operator MCS_EDrq &() const
  3034. #else
  3035. MCS_DomainMCSPDU::operator MCS_EDrq &()
  3036. {
  3037. #ifndef PASN_LEANANDMEAN
  3038.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_EDrq::Class()), PInvalidCast);
  3039. #endif
  3040.   return *(MCS_EDrq *)choice;
  3041. }
  3042.  
  3043.  
  3044. MCS_DomainMCSPDU::operator const MCS_EDrq &() const
  3045. #endif
  3046. {
  3047. #ifndef PASN_LEANANDMEAN
  3048.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_EDrq::Class()), PInvalidCast);
  3049. #endif
  3050.   return *(MCS_EDrq *)choice;
  3051. }
  3052.  
  3053.  
  3054. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3055. MCS_DomainMCSPDU::operator MCS_MCrq &() const
  3056. #else
  3057. MCS_DomainMCSPDU::operator MCS_MCrq &()
  3058. {
  3059. #ifndef PASN_LEANANDMEAN
  3060.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_MCrq::Class()), PInvalidCast);
  3061. #endif
  3062.   return *(MCS_MCrq *)choice;
  3063. }
  3064.  
  3065.  
  3066. MCS_DomainMCSPDU::operator const MCS_MCrq &() const
  3067. #endif
  3068. {
  3069. #ifndef PASN_LEANANDMEAN
  3070.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_MCrq::Class()), PInvalidCast);
  3071. #endif
  3072.   return *(MCS_MCrq *)choice;
  3073. }
  3074.  
  3075.  
  3076. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3077. MCS_DomainMCSPDU::operator MCS_MCcf &() const
  3078. #else
  3079. MCS_DomainMCSPDU::operator MCS_MCcf &()
  3080. {
  3081. #ifndef PASN_LEANANDMEAN
  3082.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_MCcf::Class()), PInvalidCast);
  3083. #endif
  3084.   return *(MCS_MCcf *)choice;
  3085. }
  3086.  
  3087.  
  3088. MCS_DomainMCSPDU::operator const MCS_MCcf &() const
  3089. #endif
  3090. {
  3091. #ifndef PASN_LEANANDMEAN
  3092.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_MCcf::Class()), PInvalidCast);
  3093. #endif
  3094.   return *(MCS_MCcf *)choice;
  3095. }
  3096.  
  3097.  
  3098. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3099. MCS_DomainMCSPDU::operator MCS_PCin &() const
  3100. #else
  3101. MCS_DomainMCSPDU::operator MCS_PCin &()
  3102. {
  3103. #ifndef PASN_LEANANDMEAN
  3104.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_PCin::Class()), PInvalidCast);
  3105. #endif
  3106.   return *(MCS_PCin *)choice;
  3107. }
  3108.  
  3109.  
  3110. MCS_DomainMCSPDU::operator const MCS_PCin &() const
  3111. #endif
  3112. {
  3113. #ifndef PASN_LEANANDMEAN
  3114.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_PCin::Class()), PInvalidCast);
  3115. #endif
  3116.   return *(MCS_PCin *)choice;
  3117. }
  3118.  
  3119.  
  3120. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3121. MCS_DomainMCSPDU::operator MCS_MTrq &() const
  3122. #else
  3123. MCS_DomainMCSPDU::operator MCS_MTrq &()
  3124. {
  3125. #ifndef PASN_LEANANDMEAN
  3126.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_MTrq::Class()), PInvalidCast);
  3127. #endif
  3128.   return *(MCS_MTrq *)choice;
  3129. }
  3130.  
  3131.  
  3132. MCS_DomainMCSPDU::operator const MCS_MTrq &() const
  3133. #endif
  3134. {
  3135. #ifndef PASN_LEANANDMEAN
  3136.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_MTrq::Class()), PInvalidCast);
  3137. #endif
  3138.   return *(MCS_MTrq *)choice;
  3139. }
  3140.  
  3141.  
  3142. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3143. MCS_DomainMCSPDU::operator MCS_MTcf &() const
  3144. #else
  3145. MCS_DomainMCSPDU::operator MCS_MTcf &()
  3146. {
  3147. #ifndef PASN_LEANANDMEAN
  3148.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_MTcf::Class()), PInvalidCast);
  3149. #endif
  3150.   return *(MCS_MTcf *)choice;
  3151. }
  3152.  
  3153.  
  3154. MCS_DomainMCSPDU::operator const MCS_MTcf &() const
  3155. #endif
  3156. {
  3157. #ifndef PASN_LEANANDMEAN
  3158.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_MTcf::Class()), PInvalidCast);
  3159. #endif
  3160.   return *(MCS_MTcf *)choice;
  3161. }
  3162.  
  3163.  
  3164. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3165. MCS_DomainMCSPDU::operator MCS_PTin &() const
  3166. #else
  3167. MCS_DomainMCSPDU::operator MCS_PTin &()
  3168. {
  3169. #ifndef PASN_LEANANDMEAN
  3170.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_PTin::Class()), PInvalidCast);
  3171. #endif
  3172.   return *(MCS_PTin *)choice;
  3173. }
  3174.  
  3175.  
  3176. MCS_DomainMCSPDU::operator const MCS_PTin &() const
  3177. #endif
  3178. {
  3179. #ifndef PASN_LEANANDMEAN
  3180.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_PTin::Class()), PInvalidCast);
  3181. #endif
  3182.   return *(MCS_PTin *)choice;
  3183. }
  3184.  
  3185.  
  3186. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3187. MCS_DomainMCSPDU::operator MCS_DPum &() const
  3188. #else
  3189. MCS_DomainMCSPDU::operator MCS_DPum &()
  3190. {
  3191. #ifndef PASN_LEANANDMEAN
  3192.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_DPum::Class()), PInvalidCast);
  3193. #endif
  3194.   return *(MCS_DPum *)choice;
  3195. }
  3196.  
  3197.  
  3198. MCS_DomainMCSPDU::operator const MCS_DPum &() const
  3199. #endif
  3200. {
  3201. #ifndef PASN_LEANANDMEAN
  3202.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_DPum::Class()), PInvalidCast);
  3203. #endif
  3204.   return *(MCS_DPum *)choice;
  3205. }
  3206.  
  3207.  
  3208. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3209. MCS_DomainMCSPDU::operator MCS_RJum &() const
  3210. #else
  3211. MCS_DomainMCSPDU::operator MCS_RJum &()
  3212. {
  3213. #ifndef PASN_LEANANDMEAN
  3214.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_RJum::Class()), PInvalidCast);
  3215. #endif
  3216.   return *(MCS_RJum *)choice;
  3217. }
  3218.  
  3219.  
  3220. MCS_DomainMCSPDU::operator const MCS_RJum &() const
  3221. #endif
  3222. {
  3223. #ifndef PASN_LEANANDMEAN
  3224.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_RJum::Class()), PInvalidCast);
  3225. #endif
  3226.   return *(MCS_RJum *)choice;
  3227. }
  3228.  
  3229.  
  3230. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3231. MCS_DomainMCSPDU::operator MCS_AUrq &() const
  3232. #else
  3233. MCS_DomainMCSPDU::operator MCS_AUrq &()
  3234. {
  3235. #ifndef PASN_LEANANDMEAN
  3236.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_AUrq::Class()), PInvalidCast);
  3237. #endif
  3238.   return *(MCS_AUrq *)choice;
  3239. }
  3240.  
  3241.  
  3242. MCS_DomainMCSPDU::operator const MCS_AUrq &() const
  3243. #endif
  3244. {
  3245. #ifndef PASN_LEANANDMEAN
  3246.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_AUrq::Class()), PInvalidCast);
  3247. #endif
  3248.   return *(MCS_AUrq *)choice;
  3249. }
  3250.  
  3251.  
  3252. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3253. MCS_DomainMCSPDU::operator MCS_AUcf &() const
  3254. #else
  3255. MCS_DomainMCSPDU::operator MCS_AUcf &()
  3256. {
  3257. #ifndef PASN_LEANANDMEAN
  3258.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_AUcf::Class()), PInvalidCast);
  3259. #endif
  3260.   return *(MCS_AUcf *)choice;
  3261. }
  3262.  
  3263.  
  3264. MCS_DomainMCSPDU::operator const MCS_AUcf &() const
  3265. #endif
  3266. {
  3267. #ifndef PASN_LEANANDMEAN
  3268.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_AUcf::Class()), PInvalidCast);
  3269. #endif
  3270.   return *(MCS_AUcf *)choice;
  3271. }
  3272.  
  3273.  
  3274. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3275. MCS_DomainMCSPDU::operator MCS_DUrq &() const
  3276. #else
  3277. MCS_DomainMCSPDU::operator MCS_DUrq &()
  3278. {
  3279. #ifndef PASN_LEANANDMEAN
  3280.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_DUrq::Class()), PInvalidCast);
  3281. #endif
  3282.   return *(MCS_DUrq *)choice;
  3283. }
  3284.  
  3285.  
  3286. MCS_DomainMCSPDU::operator const MCS_DUrq &() const
  3287. #endif
  3288. {
  3289. #ifndef PASN_LEANANDMEAN
  3290.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_DUrq::Class()), PInvalidCast);
  3291. #endif
  3292.   return *(MCS_DUrq *)choice;
  3293. }
  3294.  
  3295.  
  3296. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3297. MCS_DomainMCSPDU::operator MCS_DUin &() const
  3298. #else
  3299. MCS_DomainMCSPDU::operator MCS_DUin &()
  3300. {
  3301. #ifndef PASN_LEANANDMEAN
  3302.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_DUin::Class()), PInvalidCast);
  3303. #endif
  3304.   return *(MCS_DUin *)choice;
  3305. }
  3306.  
  3307.  
  3308. MCS_DomainMCSPDU::operator const MCS_DUin &() const
  3309. #endif
  3310. {
  3311. #ifndef PASN_LEANANDMEAN
  3312.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_DUin::Class()), PInvalidCast);
  3313. #endif
  3314.   return *(MCS_DUin *)choice;
  3315. }
  3316.  
  3317.  
  3318. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3319. MCS_DomainMCSPDU::operator MCS_CJrq &() const
  3320. #else
  3321. MCS_DomainMCSPDU::operator MCS_CJrq &()
  3322. {
  3323. #ifndef PASN_LEANANDMEAN
  3324.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CJrq::Class()), PInvalidCast);
  3325. #endif
  3326.   return *(MCS_CJrq *)choice;
  3327. }
  3328.  
  3329.  
  3330. MCS_DomainMCSPDU::operator const MCS_CJrq &() const
  3331. #endif
  3332. {
  3333. #ifndef PASN_LEANANDMEAN
  3334.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CJrq::Class()), PInvalidCast);
  3335. #endif
  3336.   return *(MCS_CJrq *)choice;
  3337. }
  3338.  
  3339.  
  3340. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3341. MCS_DomainMCSPDU::operator MCS_CJcf &() const
  3342. #else
  3343. MCS_DomainMCSPDU::operator MCS_CJcf &()
  3344. {
  3345. #ifndef PASN_LEANANDMEAN
  3346.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CJcf::Class()), PInvalidCast);
  3347. #endif
  3348.   return *(MCS_CJcf *)choice;
  3349. }
  3350.  
  3351.  
  3352. MCS_DomainMCSPDU::operator const MCS_CJcf &() const
  3353. #endif
  3354. {
  3355. #ifndef PASN_LEANANDMEAN
  3356.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CJcf::Class()), PInvalidCast);
  3357. #endif
  3358.   return *(MCS_CJcf *)choice;
  3359. }
  3360.  
  3361.  
  3362. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3363. MCS_DomainMCSPDU::operator MCS_CLrq &() const
  3364. #else
  3365. MCS_DomainMCSPDU::operator MCS_CLrq &()
  3366. {
  3367. #ifndef PASN_LEANANDMEAN
  3368.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CLrq::Class()), PInvalidCast);
  3369. #endif
  3370.   return *(MCS_CLrq *)choice;
  3371. }
  3372.  
  3373.  
  3374. MCS_DomainMCSPDU::operator const MCS_CLrq &() const
  3375. #endif
  3376. {
  3377. #ifndef PASN_LEANANDMEAN
  3378.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CLrq::Class()), PInvalidCast);
  3379. #endif
  3380.   return *(MCS_CLrq *)choice;
  3381. }
  3382.  
  3383.  
  3384. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3385. MCS_DomainMCSPDU::operator MCS_CCrq &() const
  3386. #else
  3387. MCS_DomainMCSPDU::operator MCS_CCrq &()
  3388. {
  3389. #ifndef PASN_LEANANDMEAN
  3390.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CCrq::Class()), PInvalidCast);
  3391. #endif
  3392.   return *(MCS_CCrq *)choice;
  3393. }
  3394.  
  3395.  
  3396. MCS_DomainMCSPDU::operator const MCS_CCrq &() const
  3397. #endif
  3398. {
  3399. #ifndef PASN_LEANANDMEAN
  3400.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CCrq::Class()), PInvalidCast);
  3401. #endif
  3402.   return *(MCS_CCrq *)choice;
  3403. }
  3404.  
  3405.  
  3406. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3407. MCS_DomainMCSPDU::operator MCS_CCcf &() const
  3408. #else
  3409. MCS_DomainMCSPDU::operator MCS_CCcf &()
  3410. {
  3411. #ifndef PASN_LEANANDMEAN
  3412.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CCcf::Class()), PInvalidCast);
  3413. #endif
  3414.   return *(MCS_CCcf *)choice;
  3415. }
  3416.  
  3417.  
  3418. MCS_DomainMCSPDU::operator const MCS_CCcf &() const
  3419. #endif
  3420. {
  3421. #ifndef PASN_LEANANDMEAN
  3422.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CCcf::Class()), PInvalidCast);
  3423. #endif
  3424.   return *(MCS_CCcf *)choice;
  3425. }
  3426.  
  3427.  
  3428. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3429. MCS_DomainMCSPDU::operator MCS_CDrq &() const
  3430. #else
  3431. MCS_DomainMCSPDU::operator MCS_CDrq &()
  3432. {
  3433. #ifndef PASN_LEANANDMEAN
  3434.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CDrq::Class()), PInvalidCast);
  3435. #endif
  3436.   return *(MCS_CDrq *)choice;
  3437. }
  3438.  
  3439.  
  3440. MCS_DomainMCSPDU::operator const MCS_CDrq &() const
  3441. #endif
  3442. {
  3443. #ifndef PASN_LEANANDMEAN
  3444.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CDrq::Class()), PInvalidCast);
  3445. #endif
  3446.   return *(MCS_CDrq *)choice;
  3447. }
  3448.  
  3449.  
  3450. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3451. MCS_DomainMCSPDU::operator MCS_CDin &() const
  3452. #else
  3453. MCS_DomainMCSPDU::operator MCS_CDin &()
  3454. {
  3455. #ifndef PASN_LEANANDMEAN
  3456.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CDin::Class()), PInvalidCast);
  3457. #endif
  3458.   return *(MCS_CDin *)choice;
  3459. }
  3460.  
  3461.  
  3462. MCS_DomainMCSPDU::operator const MCS_CDin &() const
  3463. #endif
  3464. {
  3465. #ifndef PASN_LEANANDMEAN
  3466.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CDin::Class()), PInvalidCast);
  3467. #endif
  3468.   return *(MCS_CDin *)choice;
  3469. }
  3470.  
  3471.  
  3472. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3473. MCS_DomainMCSPDU::operator MCS_CArq &() const
  3474. #else
  3475. MCS_DomainMCSPDU::operator MCS_CArq &()
  3476. {
  3477. #ifndef PASN_LEANANDMEAN
  3478.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CArq::Class()), PInvalidCast);
  3479. #endif
  3480.   return *(MCS_CArq *)choice;
  3481. }
  3482.  
  3483.  
  3484. MCS_DomainMCSPDU::operator const MCS_CArq &() const
  3485. #endif
  3486. {
  3487. #ifndef PASN_LEANANDMEAN
  3488.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CArq::Class()), PInvalidCast);
  3489. #endif
  3490.   return *(MCS_CArq *)choice;
  3491. }
  3492.  
  3493.  
  3494. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3495. MCS_DomainMCSPDU::operator MCS_CAin &() const
  3496. #else
  3497. MCS_DomainMCSPDU::operator MCS_CAin &()
  3498. {
  3499. #ifndef PASN_LEANANDMEAN
  3500.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CAin::Class()), PInvalidCast);
  3501. #endif
  3502.   return *(MCS_CAin *)choice;
  3503. }
  3504.  
  3505.  
  3506. MCS_DomainMCSPDU::operator const MCS_CAin &() const
  3507. #endif
  3508. {
  3509. #ifndef PASN_LEANANDMEAN
  3510.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CAin::Class()), PInvalidCast);
  3511. #endif
  3512.   return *(MCS_CAin *)choice;
  3513. }
  3514.  
  3515.  
  3516. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3517. MCS_DomainMCSPDU::operator MCS_CErq &() const
  3518. #else
  3519. MCS_DomainMCSPDU::operator MCS_CErq &()
  3520. {
  3521. #ifndef PASN_LEANANDMEAN
  3522.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CErq::Class()), PInvalidCast);
  3523. #endif
  3524.   return *(MCS_CErq *)choice;
  3525. }
  3526.  
  3527.  
  3528. MCS_DomainMCSPDU::operator const MCS_CErq &() const
  3529. #endif
  3530. {
  3531. #ifndef PASN_LEANANDMEAN
  3532.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CErq::Class()), PInvalidCast);
  3533. #endif
  3534.   return *(MCS_CErq *)choice;
  3535. }
  3536.  
  3537.  
  3538. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3539. MCS_DomainMCSPDU::operator MCS_CEin &() const
  3540. #else
  3541. MCS_DomainMCSPDU::operator MCS_CEin &()
  3542. {
  3543. #ifndef PASN_LEANANDMEAN
  3544.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CEin::Class()), PInvalidCast);
  3545. #endif
  3546.   return *(MCS_CEin *)choice;
  3547. }
  3548.  
  3549.  
  3550. MCS_DomainMCSPDU::operator const MCS_CEin &() const
  3551. #endif
  3552. {
  3553. #ifndef PASN_LEANANDMEAN
  3554.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_CEin::Class()), PInvalidCast);
  3555. #endif
  3556.   return *(MCS_CEin *)choice;
  3557. }
  3558.  
  3559.  
  3560. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3561. MCS_DomainMCSPDU::operator MCS_SDrq &() const
  3562. #else
  3563. MCS_DomainMCSPDU::operator MCS_SDrq &()
  3564. {
  3565. #ifndef PASN_LEANANDMEAN
  3566.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_SDrq::Class()), PInvalidCast);
  3567. #endif
  3568.   return *(MCS_SDrq *)choice;
  3569. }
  3570.  
  3571.  
  3572. MCS_DomainMCSPDU::operator const MCS_SDrq &() const
  3573. #endif
  3574. {
  3575. #ifndef PASN_LEANANDMEAN
  3576.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_SDrq::Class()), PInvalidCast);
  3577. #endif
  3578.   return *(MCS_SDrq *)choice;
  3579. }
  3580.  
  3581.  
  3582. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3583. MCS_DomainMCSPDU::operator MCS_SDin &() const
  3584. #else
  3585. MCS_DomainMCSPDU::operator MCS_SDin &()
  3586. {
  3587. #ifndef PASN_LEANANDMEAN
  3588.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_SDin::Class()), PInvalidCast);
  3589. #endif
  3590.   return *(MCS_SDin *)choice;
  3591. }
  3592.  
  3593.  
  3594. MCS_DomainMCSPDU::operator const MCS_SDin &() const
  3595. #endif
  3596. {
  3597. #ifndef PASN_LEANANDMEAN
  3598.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_SDin::Class()), PInvalidCast);
  3599. #endif
  3600.   return *(MCS_SDin *)choice;
  3601. }
  3602.  
  3603.  
  3604. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3605. MCS_DomainMCSPDU::operator MCS_USrq &() const
  3606. #else
  3607. MCS_DomainMCSPDU::operator MCS_USrq &()
  3608. {
  3609. #ifndef PASN_LEANANDMEAN
  3610.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_USrq::Class()), PInvalidCast);
  3611. #endif
  3612.   return *(MCS_USrq *)choice;
  3613. }
  3614.  
  3615.  
  3616. MCS_DomainMCSPDU::operator const MCS_USrq &() const
  3617. #endif
  3618. {
  3619. #ifndef PASN_LEANANDMEAN
  3620.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_USrq::Class()), PInvalidCast);
  3621. #endif
  3622.   return *(MCS_USrq *)choice;
  3623. }
  3624.  
  3625.  
  3626. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3627. MCS_DomainMCSPDU::operator MCS_USin &() const
  3628. #else
  3629. MCS_DomainMCSPDU::operator MCS_USin &()
  3630. {
  3631. #ifndef PASN_LEANANDMEAN
  3632.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_USin::Class()), PInvalidCast);
  3633. #endif
  3634.   return *(MCS_USin *)choice;
  3635. }
  3636.  
  3637.  
  3638. MCS_DomainMCSPDU::operator const MCS_USin &() const
  3639. #endif
  3640. {
  3641. #ifndef PASN_LEANANDMEAN
  3642.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_USin::Class()), PInvalidCast);
  3643. #endif
  3644.   return *(MCS_USin *)choice;
  3645. }
  3646.  
  3647.  
  3648. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3649. MCS_DomainMCSPDU::operator MCS_TGrq &() const
  3650. #else
  3651. MCS_DomainMCSPDU::operator MCS_TGrq &()
  3652. {
  3653. #ifndef PASN_LEANANDMEAN
  3654.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TGrq::Class()), PInvalidCast);
  3655. #endif
  3656.   return *(MCS_TGrq *)choice;
  3657. }
  3658.  
  3659.  
  3660. MCS_DomainMCSPDU::operator const MCS_TGrq &() const
  3661. #endif
  3662. {
  3663. #ifndef PASN_LEANANDMEAN
  3664.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TGrq::Class()), PInvalidCast);
  3665. #endif
  3666.   return *(MCS_TGrq *)choice;
  3667. }
  3668.  
  3669.  
  3670. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3671. MCS_DomainMCSPDU::operator MCS_TGcf &() const
  3672. #else
  3673. MCS_DomainMCSPDU::operator MCS_TGcf &()
  3674. {
  3675. #ifndef PASN_LEANANDMEAN
  3676.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TGcf::Class()), PInvalidCast);
  3677. #endif
  3678.   return *(MCS_TGcf *)choice;
  3679. }
  3680.  
  3681.  
  3682. MCS_DomainMCSPDU::operator const MCS_TGcf &() const
  3683. #endif
  3684. {
  3685. #ifndef PASN_LEANANDMEAN
  3686.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TGcf::Class()), PInvalidCast);
  3687. #endif
  3688.   return *(MCS_TGcf *)choice;
  3689. }
  3690.  
  3691.  
  3692. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3693. MCS_DomainMCSPDU::operator MCS_TIrq &() const
  3694. #else
  3695. MCS_DomainMCSPDU::operator MCS_TIrq &()
  3696. {
  3697. #ifndef PASN_LEANANDMEAN
  3698.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TIrq::Class()), PInvalidCast);
  3699. #endif
  3700.   return *(MCS_TIrq *)choice;
  3701. }
  3702.  
  3703.  
  3704. MCS_DomainMCSPDU::operator const MCS_TIrq &() const
  3705. #endif
  3706. {
  3707. #ifndef PASN_LEANANDMEAN
  3708.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TIrq::Class()), PInvalidCast);
  3709. #endif
  3710.   return *(MCS_TIrq *)choice;
  3711. }
  3712.  
  3713.  
  3714. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3715. MCS_DomainMCSPDU::operator MCS_TIcf &() const
  3716. #else
  3717. MCS_DomainMCSPDU::operator MCS_TIcf &()
  3718. {
  3719. #ifndef PASN_LEANANDMEAN
  3720.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TIcf::Class()), PInvalidCast);
  3721. #endif
  3722.   return *(MCS_TIcf *)choice;
  3723. }
  3724.  
  3725.  
  3726. MCS_DomainMCSPDU::operator const MCS_TIcf &() const
  3727. #endif
  3728. {
  3729. #ifndef PASN_LEANANDMEAN
  3730.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TIcf::Class()), PInvalidCast);
  3731. #endif
  3732.   return *(MCS_TIcf *)choice;
  3733. }
  3734.  
  3735.  
  3736. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3737. MCS_DomainMCSPDU::operator MCS_TVrq &() const
  3738. #else
  3739. MCS_DomainMCSPDU::operator MCS_TVrq &()
  3740. {
  3741. #ifndef PASN_LEANANDMEAN
  3742.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TVrq::Class()), PInvalidCast);
  3743. #endif
  3744.   return *(MCS_TVrq *)choice;
  3745. }
  3746.  
  3747.  
  3748. MCS_DomainMCSPDU::operator const MCS_TVrq &() const
  3749. #endif
  3750. {
  3751. #ifndef PASN_LEANANDMEAN
  3752.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TVrq::Class()), PInvalidCast);
  3753. #endif
  3754.   return *(MCS_TVrq *)choice;
  3755. }
  3756.  
  3757.  
  3758. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3759. MCS_DomainMCSPDU::operator MCS_TVin &() const
  3760. #else
  3761. MCS_DomainMCSPDU::operator MCS_TVin &()
  3762. {
  3763. #ifndef PASN_LEANANDMEAN
  3764.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TVin::Class()), PInvalidCast);
  3765. #endif
  3766.   return *(MCS_TVin *)choice;
  3767. }
  3768.  
  3769.  
  3770. MCS_DomainMCSPDU::operator const MCS_TVin &() const
  3771. #endif
  3772. {
  3773. #ifndef PASN_LEANANDMEAN
  3774.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TVin::Class()), PInvalidCast);
  3775. #endif
  3776.   return *(MCS_TVin *)choice;
  3777. }
  3778.  
  3779.  
  3780. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3781. MCS_DomainMCSPDU::operator MCS_TVrs &() const
  3782. #else
  3783. MCS_DomainMCSPDU::operator MCS_TVrs &()
  3784. {
  3785. #ifndef PASN_LEANANDMEAN
  3786.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TVrs::Class()), PInvalidCast);
  3787. #endif
  3788.   return *(MCS_TVrs *)choice;
  3789. }
  3790.  
  3791.  
  3792. MCS_DomainMCSPDU::operator const MCS_TVrs &() const
  3793. #endif
  3794. {
  3795. #ifndef PASN_LEANANDMEAN
  3796.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TVrs::Class()), PInvalidCast);
  3797. #endif
  3798.   return *(MCS_TVrs *)choice;
  3799. }
  3800.  
  3801.  
  3802. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3803. MCS_DomainMCSPDU::operator MCS_TVcf &() const
  3804. #else
  3805. MCS_DomainMCSPDU::operator MCS_TVcf &()
  3806. {
  3807. #ifndef PASN_LEANANDMEAN
  3808.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TVcf::Class()), PInvalidCast);
  3809. #endif
  3810.   return *(MCS_TVcf *)choice;
  3811. }
  3812.  
  3813.  
  3814. MCS_DomainMCSPDU::operator const MCS_TVcf &() const
  3815. #endif
  3816. {
  3817. #ifndef PASN_LEANANDMEAN
  3818.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TVcf::Class()), PInvalidCast);
  3819. #endif
  3820.   return *(MCS_TVcf *)choice;
  3821. }
  3822.  
  3823.  
  3824. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3825. MCS_DomainMCSPDU::operator MCS_TPrq &() const
  3826. #else
  3827. MCS_DomainMCSPDU::operator MCS_TPrq &()
  3828. {
  3829. #ifndef PASN_LEANANDMEAN
  3830.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TPrq::Class()), PInvalidCast);
  3831. #endif
  3832.   return *(MCS_TPrq *)choice;
  3833. }
  3834.  
  3835.  
  3836. MCS_DomainMCSPDU::operator const MCS_TPrq &() const
  3837. #endif
  3838. {
  3839. #ifndef PASN_LEANANDMEAN
  3840.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TPrq::Class()), PInvalidCast);
  3841. #endif
  3842.   return *(MCS_TPrq *)choice;
  3843. }
  3844.  
  3845.  
  3846. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3847. MCS_DomainMCSPDU::operator MCS_TPin &() const
  3848. #else
  3849. MCS_DomainMCSPDU::operator MCS_TPin &()
  3850. {
  3851. #ifndef PASN_LEANANDMEAN
  3852.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TPin::Class()), PInvalidCast);
  3853. #endif
  3854.   return *(MCS_TPin *)choice;
  3855. }
  3856.  
  3857.  
  3858. MCS_DomainMCSPDU::operator const MCS_TPin &() const
  3859. #endif
  3860. {
  3861. #ifndef PASN_LEANANDMEAN
  3862.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TPin::Class()), PInvalidCast);
  3863. #endif
  3864.   return *(MCS_TPin *)choice;
  3865. }
  3866.  
  3867.  
  3868. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3869. MCS_DomainMCSPDU::operator MCS_TRrq &() const
  3870. #else
  3871. MCS_DomainMCSPDU::operator MCS_TRrq &()
  3872. {
  3873. #ifndef PASN_LEANANDMEAN
  3874.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TRrq::Class()), PInvalidCast);
  3875. #endif
  3876.   return *(MCS_TRrq *)choice;
  3877. }
  3878.  
  3879.  
  3880. MCS_DomainMCSPDU::operator const MCS_TRrq &() const
  3881. #endif
  3882. {
  3883. #ifndef PASN_LEANANDMEAN
  3884.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TRrq::Class()), PInvalidCast);
  3885. #endif
  3886.   return *(MCS_TRrq *)choice;
  3887. }
  3888.  
  3889.  
  3890. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3891. MCS_DomainMCSPDU::operator MCS_TRcf &() const
  3892. #else
  3893. MCS_DomainMCSPDU::operator MCS_TRcf &()
  3894. {
  3895. #ifndef PASN_LEANANDMEAN
  3896.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TRcf::Class()), PInvalidCast);
  3897. #endif
  3898.   return *(MCS_TRcf *)choice;
  3899. }
  3900.  
  3901.  
  3902. MCS_DomainMCSPDU::operator const MCS_TRcf &() const
  3903. #endif
  3904. {
  3905. #ifndef PASN_LEANANDMEAN
  3906.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TRcf::Class()), PInvalidCast);
  3907. #endif
  3908.   return *(MCS_TRcf *)choice;
  3909. }
  3910.  
  3911.  
  3912. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3913. MCS_DomainMCSPDU::operator MCS_TTrq &() const
  3914. #else
  3915. MCS_DomainMCSPDU::operator MCS_TTrq &()
  3916. {
  3917. #ifndef PASN_LEANANDMEAN
  3918.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TTrq::Class()), PInvalidCast);
  3919. #endif
  3920.   return *(MCS_TTrq *)choice;
  3921. }
  3922.  
  3923.  
  3924. MCS_DomainMCSPDU::operator const MCS_TTrq &() const
  3925. #endif
  3926. {
  3927. #ifndef PASN_LEANANDMEAN
  3928.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TTrq::Class()), PInvalidCast);
  3929. #endif
  3930.   return *(MCS_TTrq *)choice;
  3931. }
  3932.  
  3933.  
  3934. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  3935. MCS_DomainMCSPDU::operator MCS_TTcf &() const
  3936. #else
  3937. MCS_DomainMCSPDU::operator MCS_TTcf &()
  3938. {
  3939. #ifndef PASN_LEANANDMEAN
  3940.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TTcf::Class()), PInvalidCast);
  3941. #endif
  3942.   return *(MCS_TTcf *)choice;
  3943. }
  3944.  
  3945.  
  3946. MCS_DomainMCSPDU::operator const MCS_TTcf &() const
  3947. #endif
  3948. {
  3949. #ifndef PASN_LEANANDMEAN
  3950.   PAssert(PAssertNULL(choice)->IsDescendant(MCS_TTcf::Class()), PInvalidCast);
  3951. #endif
  3952.   return *(MCS_TTcf *)choice;
  3953. }
  3954.  
  3955.  
  3956. BOOL MCS_DomainMCSPDU::CreateObject()
  3957. {
  3958.   switch (tag) {
  3959.     case e_pdin :
  3960.       choice = new MCS_PDin();
  3961.       return TRUE;
  3962.     case e_edrq :
  3963.       choice = new MCS_EDrq();
  3964.       return TRUE;
  3965.     case e_mcrq :
  3966.       choice = new MCS_MCrq();
  3967.       return TRUE;
  3968.     case e_mccf :
  3969.       choice = new MCS_MCcf();
  3970.       return TRUE;
  3971.     case e_pcin :
  3972.       choice = new MCS_PCin();
  3973.       return TRUE;
  3974.     case e_mtrq :
  3975.       choice = new MCS_MTrq();
  3976.       return TRUE;
  3977.     case e_mtcf :
  3978.       choice = new MCS_MTcf();
  3979.       return TRUE;
  3980.     case e_ptin :
  3981.       choice = new MCS_PTin();
  3982.       return TRUE;
  3983.     case e_dpum :
  3984.       choice = new MCS_DPum();
  3985.       return TRUE;
  3986.     case e_rjum :
  3987.       choice = new MCS_RJum();
  3988.       return TRUE;
  3989.     case e_aurq :
  3990.       choice = new MCS_AUrq();
  3991.       return TRUE;
  3992.     case e_aucf :
  3993.       choice = new MCS_AUcf();
  3994.       return TRUE;
  3995.     case e_durq :
  3996.       choice = new MCS_DUrq();
  3997.       return TRUE;
  3998.     case e_duin :
  3999.       choice = new MCS_DUin();
  4000.       return TRUE;
  4001.     case e_cjrq :
  4002.       choice = new MCS_CJrq();
  4003.       return TRUE;
  4004.     case e_cjcf :
  4005.       choice = new MCS_CJcf();
  4006.       return TRUE;
  4007.     case e_clrq :
  4008.       choice = new MCS_CLrq();
  4009.       return TRUE;
  4010.     case e_ccrq :
  4011.       choice = new MCS_CCrq();
  4012.       return TRUE;
  4013.     case e_cccf :
  4014.       choice = new MCS_CCcf();
  4015.       return TRUE;
  4016.     case e_cdrq :
  4017.       choice = new MCS_CDrq();
  4018.       return TRUE;
  4019.     case e_cdin :
  4020.       choice = new MCS_CDin();
  4021.       return TRUE;
  4022.     case e_carq :
  4023.       choice = new MCS_CArq();
  4024.       return TRUE;
  4025.     case e_cain :
  4026.       choice = new MCS_CAin();
  4027.       return TRUE;
  4028.     case e_cerq :
  4029.       choice = new MCS_CErq();
  4030.       return TRUE;
  4031.     case e_cein :
  4032.       choice = new MCS_CEin();
  4033.       return TRUE;
  4034.     case e_sdrq :
  4035.       choice = new MCS_SDrq();
  4036.       return TRUE;
  4037.     case e_sdin :
  4038.       choice = new MCS_SDin();
  4039.       return TRUE;
  4040.     case e_usrq :
  4041.       choice = new MCS_USrq();
  4042.       return TRUE;
  4043.     case e_usin :
  4044.       choice = new MCS_USin();
  4045.       return TRUE;
  4046.     case e_tgrq :
  4047.       choice = new MCS_TGrq();
  4048.       return TRUE;
  4049.     case e_tgcf :
  4050.       choice = new MCS_TGcf();
  4051.       return TRUE;
  4052.     case e_tirq :
  4053.       choice = new MCS_TIrq();
  4054.       return TRUE;
  4055.     case e_ticf :
  4056.       choice = new MCS_TIcf();
  4057.       return TRUE;
  4058.     case e_tvrq :
  4059.       choice = new MCS_TVrq();
  4060.       return TRUE;
  4061.     case e_tvin :
  4062.       choice = new MCS_TVin();
  4063.       return TRUE;
  4064.     case e_tvrs :
  4065.       choice = new MCS_TVrs();
  4066.       return TRUE;
  4067.     case e_tvcf :
  4068.       choice = new MCS_TVcf();
  4069.       return TRUE;
  4070.     case e_tprq :
  4071.       choice = new MCS_TPrq();
  4072.       return TRUE;
  4073.     case e_tpin :
  4074.       choice = new MCS_TPin();
  4075.       return TRUE;
  4076.     case e_trrq :
  4077.       choice = new MCS_TRrq();
  4078.       return TRUE;
  4079.     case e_trcf :
  4080.       choice = new MCS_TRcf();
  4081.       return TRUE;
  4082.     case e_ttrq :
  4083.       choice = new MCS_TTrq();
  4084.       return TRUE;
  4085.     case e_ttcf :
  4086.       choice = new MCS_TTcf();
  4087.       return TRUE;
  4088.   }
  4089.  
  4090.   choice = NULL;
  4091.   return FALSE;
  4092. }
  4093.  
  4094.  
  4095. PObject * MCS_DomainMCSPDU::Clone() const
  4096. {
  4097. #ifndef PASN_LEANANDMEAN
  4098.   PAssert(IsClass(MCS_DomainMCSPDU::Class()), PInvalidCast);
  4099. #endif
  4100.   return new MCS_DomainMCSPDU(*this);
  4101. }
  4102.  
  4103.  
  4104. //
  4105. // ChannelAttributes_static
  4106. //
  4107.  
  4108. MCS_ChannelAttributes_static::MCS_ChannelAttributes_static(unsigned tag, PASN_Object::TagClass tagClass)
  4109.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4110. {
  4111. }
  4112.  
  4113.  
  4114. #ifndef PASN_NOPRINTON
  4115. void MCS_ChannelAttributes_static::PrintOn(ostream & strm) const
  4116. {
  4117.   int indent = strm.precision() + 2;
  4118.   strm << "{\n";
  4119.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  4120.   strm << setw(indent-1) << "}";
  4121. }
  4122. #endif
  4123.  
  4124.  
  4125. PObject::Comparison MCS_ChannelAttributes_static::Compare(const PObject & obj) const
  4126. {
  4127. #ifndef PASN_LEANANDMEAN
  4128.   PAssert(IsDescendant(MCS_ChannelAttributes_static::Class()), PInvalidCast);
  4129. #endif
  4130.   const MCS_ChannelAttributes_static & other = (const MCS_ChannelAttributes_static &)obj;
  4131.  
  4132.   Comparison result;
  4133.  
  4134.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  4135.     return result;
  4136.  
  4137.   return PASN_Sequence::Compare(other);
  4138. }
  4139.  
  4140.  
  4141. PINDEX MCS_ChannelAttributes_static::GetDataLength() const
  4142. {
  4143.   PINDEX length = 0;
  4144.   length += m_channelId.GetObjectLength();
  4145.   return length;
  4146. }
  4147.  
  4148.  
  4149. BOOL MCS_ChannelAttributes_static::Decode(PASN_Stream & strm)
  4150. {
  4151.   if (!PreambleDecode(strm))
  4152.     return FALSE;
  4153.  
  4154.   if (!m_channelId.Decode(strm))
  4155.     return FALSE;
  4156.  
  4157.   return UnknownExtensionsDecode(strm);
  4158. }
  4159.  
  4160.  
  4161. void MCS_ChannelAttributes_static::Encode(PASN_Stream & strm) const
  4162. {
  4163.   PreambleEncode(strm);
  4164.  
  4165.   m_channelId.Encode(strm);
  4166.  
  4167.   UnknownExtensionsEncode(strm);
  4168. }
  4169.  
  4170.  
  4171. PObject * MCS_ChannelAttributes_static::Clone() const
  4172. {
  4173. #ifndef PASN_LEANANDMEAN
  4174.   PAssert(IsClass(MCS_ChannelAttributes_static::Class()), PInvalidCast);
  4175. #endif
  4176.   return new MCS_ChannelAttributes_static(*this);
  4177. }
  4178.  
  4179.  
  4180. //
  4181. // ChannelAttributes_userId
  4182. //
  4183.  
  4184. MCS_ChannelAttributes_userId::MCS_ChannelAttributes_userId(unsigned tag, PASN_Object::TagClass tagClass)
  4185.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4186. {
  4187. }
  4188.  
  4189.  
  4190. #ifndef PASN_NOPRINTON
  4191. void MCS_ChannelAttributes_userId::PrintOn(ostream & strm) const
  4192. {
  4193.   int indent = strm.precision() + 2;
  4194.   strm << "{\n";
  4195.   strm << setw(indent+9) << "joined = " << setprecision(indent) << m_joined << '\n';
  4196.   strm << setw(indent+9) << "userId = " << setprecision(indent) << m_userId << '\n';
  4197.   strm << setw(indent-1) << "}";
  4198. }
  4199. #endif
  4200.  
  4201.  
  4202. PObject::Comparison MCS_ChannelAttributes_userId::Compare(const PObject & obj) const
  4203. {
  4204. #ifndef PASN_LEANANDMEAN
  4205.   PAssert(IsDescendant(MCS_ChannelAttributes_userId::Class()), PInvalidCast);
  4206. #endif
  4207.   const MCS_ChannelAttributes_userId & other = (const MCS_ChannelAttributes_userId &)obj;
  4208.  
  4209.   Comparison result;
  4210.  
  4211.   if ((result = m_joined.Compare(other.m_joined)) != EqualTo)
  4212.     return result;
  4213.   if ((result = m_userId.Compare(other.m_userId)) != EqualTo)
  4214.     return result;
  4215.  
  4216.   return PASN_Sequence::Compare(other);
  4217. }
  4218.  
  4219.  
  4220. PINDEX MCS_ChannelAttributes_userId::GetDataLength() const
  4221. {
  4222.   PINDEX length = 0;
  4223.   length += m_joined.GetObjectLength();
  4224.   length += m_userId.GetObjectLength();
  4225.   return length;
  4226. }
  4227.  
  4228.  
  4229. BOOL MCS_ChannelAttributes_userId::Decode(PASN_Stream & strm)
  4230. {
  4231.   if (!PreambleDecode(strm))
  4232.     return FALSE;
  4233.  
  4234.   if (!m_joined.Decode(strm))
  4235.     return FALSE;
  4236.   if (!m_userId.Decode(strm))
  4237.     return FALSE;
  4238.  
  4239.   return UnknownExtensionsDecode(strm);
  4240. }
  4241.  
  4242.  
  4243. void MCS_ChannelAttributes_userId::Encode(PASN_Stream & strm) const
  4244. {
  4245.   PreambleEncode(strm);
  4246.  
  4247.   m_joined.Encode(strm);
  4248.   m_userId.Encode(strm);
  4249.  
  4250.   UnknownExtensionsEncode(strm);
  4251. }
  4252.  
  4253.  
  4254. PObject * MCS_ChannelAttributes_userId::Clone() const
  4255. {
  4256. #ifndef PASN_LEANANDMEAN
  4257.   PAssert(IsClass(MCS_ChannelAttributes_userId::Class()), PInvalidCast);
  4258. #endif
  4259.   return new MCS_ChannelAttributes_userId(*this);
  4260. }
  4261.  
  4262.  
  4263. //
  4264. // ChannelAttributes_assigned
  4265. //
  4266.  
  4267. MCS_ChannelAttributes_assigned::MCS_ChannelAttributes_assigned(unsigned tag, PASN_Object::TagClass tagClass)
  4268.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4269. {
  4270. }
  4271.  
  4272.  
  4273. #ifndef PASN_NOPRINTON
  4274. void MCS_ChannelAttributes_assigned::PrintOn(ostream & strm) const
  4275. {
  4276.   int indent = strm.precision() + 2;
  4277.   strm << "{\n";
  4278.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  4279.   strm << setw(indent-1) << "}";
  4280. }
  4281. #endif
  4282.  
  4283.  
  4284. PObject::Comparison MCS_ChannelAttributes_assigned::Compare(const PObject & obj) const
  4285. {
  4286. #ifndef PASN_LEANANDMEAN
  4287.   PAssert(IsDescendant(MCS_ChannelAttributes_assigned::Class()), PInvalidCast);
  4288. #endif
  4289.   const MCS_ChannelAttributes_assigned & other = (const MCS_ChannelAttributes_assigned &)obj;
  4290.  
  4291.   Comparison result;
  4292.  
  4293.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  4294.     return result;
  4295.  
  4296.   return PASN_Sequence::Compare(other);
  4297. }
  4298.  
  4299.  
  4300. PINDEX MCS_ChannelAttributes_assigned::GetDataLength() const
  4301. {
  4302.   PINDEX length = 0;
  4303.   length += m_channelId.GetObjectLength();
  4304.   return length;
  4305. }
  4306.  
  4307.  
  4308. BOOL MCS_ChannelAttributes_assigned::Decode(PASN_Stream & strm)
  4309. {
  4310.   if (!PreambleDecode(strm))
  4311.     return FALSE;
  4312.  
  4313.   if (!m_channelId.Decode(strm))
  4314.     return FALSE;
  4315.  
  4316.   return UnknownExtensionsDecode(strm);
  4317. }
  4318.  
  4319.  
  4320. void MCS_ChannelAttributes_assigned::Encode(PASN_Stream & strm) const
  4321. {
  4322.   PreambleEncode(strm);
  4323.  
  4324.   m_channelId.Encode(strm);
  4325.  
  4326.   UnknownExtensionsEncode(strm);
  4327. }
  4328.  
  4329.  
  4330. PObject * MCS_ChannelAttributes_assigned::Clone() const
  4331. {
  4332. #ifndef PASN_LEANANDMEAN
  4333.   PAssert(IsClass(MCS_ChannelAttributes_assigned::Class()), PInvalidCast);
  4334. #endif
  4335.   return new MCS_ChannelAttributes_assigned(*this);
  4336. }
  4337.  
  4338.  
  4339. //
  4340. // ArrayOf_ChannelAttributes
  4341. //
  4342.  
  4343. MCS_ArrayOf_ChannelAttributes::MCS_ArrayOf_ChannelAttributes(unsigned tag, PASN_Object::TagClass tagClass)
  4344.   : PASN_Array(tag, tagClass)
  4345. {
  4346. }
  4347.  
  4348.  
  4349. PASN_Object * MCS_ArrayOf_ChannelAttributes::CreateObject() const
  4350. {
  4351.   return new MCS_ChannelAttributes;
  4352. }
  4353.  
  4354.  
  4355. MCS_ChannelAttributes & MCS_ArrayOf_ChannelAttributes::operator[](PINDEX i) const
  4356. {
  4357.   return (MCS_ChannelAttributes &)array[i];
  4358. }
  4359.  
  4360.  
  4361. PObject * MCS_ArrayOf_ChannelAttributes::Clone() const
  4362. {
  4363. #ifndef PASN_LEANANDMEAN
  4364.   PAssert(IsClass(MCS_ArrayOf_ChannelAttributes::Class()), PInvalidCast);
  4365. #endif
  4366.   return new MCS_ArrayOf_ChannelAttributes(*this);
  4367. }
  4368.  
  4369.  
  4370. //
  4371. // ArrayOf_ChannelId
  4372. //
  4373.  
  4374. MCS_ArrayOf_ChannelId::MCS_ArrayOf_ChannelId(unsigned tag, PASN_Object::TagClass tagClass)
  4375.   : PASN_Array(tag, tagClass)
  4376. {
  4377. }
  4378.  
  4379.  
  4380. PASN_Object * MCS_ArrayOf_ChannelId::CreateObject() const
  4381. {
  4382.   return new MCS_ChannelId;
  4383. }
  4384.  
  4385.  
  4386. MCS_ChannelId & MCS_ArrayOf_ChannelId::operator[](PINDEX i) const
  4387. {
  4388.   return (MCS_ChannelId &)array[i];
  4389. }
  4390.  
  4391.  
  4392. PObject * MCS_ArrayOf_ChannelId::Clone() const
  4393. {
  4394. #ifndef PASN_LEANANDMEAN
  4395.   PAssert(IsClass(MCS_ArrayOf_ChannelId::Class()), PInvalidCast);
  4396. #endif
  4397.   return new MCS_ArrayOf_ChannelId(*this);
  4398. }
  4399.  
  4400.  
  4401. //
  4402. // ArrayOf_UserId
  4403. //
  4404.  
  4405. MCS_ArrayOf_UserId::MCS_ArrayOf_UserId(unsigned tag, PASN_Object::TagClass tagClass)
  4406.   : PASN_Array(tag, tagClass)
  4407. {
  4408. }
  4409.  
  4410.  
  4411. PASN_Object * MCS_ArrayOf_UserId::CreateObject() const
  4412. {
  4413.   return new MCS_UserId;
  4414. }
  4415.  
  4416.  
  4417. MCS_UserId & MCS_ArrayOf_UserId::operator[](PINDEX i) const
  4418. {
  4419.   return (MCS_UserId &)array[i];
  4420. }
  4421.  
  4422.  
  4423. PObject * MCS_ArrayOf_UserId::Clone() const
  4424. {
  4425. #ifndef PASN_LEANANDMEAN
  4426.   PAssert(IsClass(MCS_ArrayOf_UserId::Class()), PInvalidCast);
  4427. #endif
  4428.   return new MCS_ArrayOf_UserId(*this);
  4429. }
  4430.  
  4431.  
  4432. //
  4433. // TokenAttributes_grabbed
  4434. //
  4435.  
  4436. MCS_TokenAttributes_grabbed::MCS_TokenAttributes_grabbed(unsigned tag, PASN_Object::TagClass tagClass)
  4437.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4438. {
  4439. }
  4440.  
  4441.  
  4442. #ifndef PASN_NOPRINTON
  4443. void MCS_TokenAttributes_grabbed::PrintOn(ostream & strm) const
  4444. {
  4445.   int indent = strm.precision() + 2;
  4446.   strm << "{\n";
  4447.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  4448.   strm << setw(indent+10) << "grabber = " << setprecision(indent) << m_grabber << '\n';
  4449.   strm << setw(indent-1) << "}";
  4450. }
  4451. #endif
  4452.  
  4453.  
  4454. PObject::Comparison MCS_TokenAttributes_grabbed::Compare(const PObject & obj) const
  4455. {
  4456. #ifndef PASN_LEANANDMEAN
  4457.   PAssert(IsDescendant(MCS_TokenAttributes_grabbed::Class()), PInvalidCast);
  4458. #endif
  4459.   const MCS_TokenAttributes_grabbed & other = (const MCS_TokenAttributes_grabbed &)obj;
  4460.  
  4461.   Comparison result;
  4462.  
  4463.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  4464.     return result;
  4465.   if ((result = m_grabber.Compare(other.m_grabber)) != EqualTo)
  4466.     return result;
  4467.  
  4468.   return PASN_Sequence::Compare(other);
  4469. }
  4470.  
  4471.  
  4472. PINDEX MCS_TokenAttributes_grabbed::GetDataLength() const
  4473. {
  4474.   PINDEX length = 0;
  4475.   length += m_tokenId.GetObjectLength();
  4476.   length += m_grabber.GetObjectLength();
  4477.   return length;
  4478. }
  4479.  
  4480.  
  4481. BOOL MCS_TokenAttributes_grabbed::Decode(PASN_Stream & strm)
  4482. {
  4483.   if (!PreambleDecode(strm))
  4484.     return FALSE;
  4485.  
  4486.   if (!m_tokenId.Decode(strm))
  4487.     return FALSE;
  4488.   if (!m_grabber.Decode(strm))
  4489.     return FALSE;
  4490.  
  4491.   return UnknownExtensionsDecode(strm);
  4492. }
  4493.  
  4494.  
  4495. void MCS_TokenAttributes_grabbed::Encode(PASN_Stream & strm) const
  4496. {
  4497.   PreambleEncode(strm);
  4498.  
  4499.   m_tokenId.Encode(strm);
  4500.   m_grabber.Encode(strm);
  4501.  
  4502.   UnknownExtensionsEncode(strm);
  4503. }
  4504.  
  4505.  
  4506. PObject * MCS_TokenAttributes_grabbed::Clone() const
  4507. {
  4508. #ifndef PASN_LEANANDMEAN
  4509.   PAssert(IsClass(MCS_TokenAttributes_grabbed::Class()), PInvalidCast);
  4510. #endif
  4511.   return new MCS_TokenAttributes_grabbed(*this);
  4512. }
  4513.  
  4514.  
  4515. //
  4516. // TokenAttributes_inhibited
  4517. //
  4518.  
  4519. MCS_TokenAttributes_inhibited::MCS_TokenAttributes_inhibited(unsigned tag, PASN_Object::TagClass tagClass)
  4520.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4521. {
  4522. }
  4523.  
  4524.  
  4525. #ifndef PASN_NOPRINTON
  4526. void MCS_TokenAttributes_inhibited::PrintOn(ostream & strm) const
  4527. {
  4528.   int indent = strm.precision() + 2;
  4529.   strm << "{\n";
  4530.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  4531.   strm << setw(indent+13) << "inhibitors = " << setprecision(indent) << m_inhibitors << '\n';
  4532.   strm << setw(indent-1) << "}";
  4533. }
  4534. #endif
  4535.  
  4536.  
  4537. PObject::Comparison MCS_TokenAttributes_inhibited::Compare(const PObject & obj) const
  4538. {
  4539. #ifndef PASN_LEANANDMEAN
  4540.   PAssert(IsDescendant(MCS_TokenAttributes_inhibited::Class()), PInvalidCast);
  4541. #endif
  4542.   const MCS_TokenAttributes_inhibited & other = (const MCS_TokenAttributes_inhibited &)obj;
  4543.  
  4544.   Comparison result;
  4545.  
  4546.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  4547.     return result;
  4548.   if ((result = m_inhibitors.Compare(other.m_inhibitors)) != EqualTo)
  4549.     return result;
  4550.  
  4551.   return PASN_Sequence::Compare(other);
  4552. }
  4553.  
  4554.  
  4555. PINDEX MCS_TokenAttributes_inhibited::GetDataLength() const
  4556. {
  4557.   PINDEX length = 0;
  4558.   length += m_tokenId.GetObjectLength();
  4559.   length += m_inhibitors.GetObjectLength();
  4560.   return length;
  4561. }
  4562.  
  4563.  
  4564. BOOL MCS_TokenAttributes_inhibited::Decode(PASN_Stream & strm)
  4565. {
  4566.   if (!PreambleDecode(strm))
  4567.     return FALSE;
  4568.  
  4569.   if (!m_tokenId.Decode(strm))
  4570.     return FALSE;
  4571.   if (!m_inhibitors.Decode(strm))
  4572.     return FALSE;
  4573.  
  4574.   return UnknownExtensionsDecode(strm);
  4575. }
  4576.  
  4577.  
  4578. void MCS_TokenAttributes_inhibited::Encode(PASN_Stream & strm) const
  4579. {
  4580.   PreambleEncode(strm);
  4581.  
  4582.   m_tokenId.Encode(strm);
  4583.   m_inhibitors.Encode(strm);
  4584.  
  4585.   UnknownExtensionsEncode(strm);
  4586. }
  4587.  
  4588.  
  4589. PObject * MCS_TokenAttributes_inhibited::Clone() const
  4590. {
  4591. #ifndef PASN_LEANANDMEAN
  4592.   PAssert(IsClass(MCS_TokenAttributes_inhibited::Class()), PInvalidCast);
  4593. #endif
  4594.   return new MCS_TokenAttributes_inhibited(*this);
  4595. }
  4596.  
  4597.  
  4598. //
  4599. // TokenAttributes_giving
  4600. //
  4601.  
  4602. MCS_TokenAttributes_giving::MCS_TokenAttributes_giving(unsigned tag, PASN_Object::TagClass tagClass)
  4603.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4604. {
  4605. }
  4606.  
  4607.  
  4608. #ifndef PASN_NOPRINTON
  4609. void MCS_TokenAttributes_giving::PrintOn(ostream & strm) const
  4610. {
  4611.   int indent = strm.precision() + 2;
  4612.   strm << "{\n";
  4613.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  4614.   strm << setw(indent+10) << "grabber = " << setprecision(indent) << m_grabber << '\n';
  4615.   strm << setw(indent+12) << "recipient = " << setprecision(indent) << m_recipient << '\n';
  4616.   strm << setw(indent-1) << "}";
  4617. }
  4618. #endif
  4619.  
  4620.  
  4621. PObject::Comparison MCS_TokenAttributes_giving::Compare(const PObject & obj) const
  4622. {
  4623. #ifndef PASN_LEANANDMEAN
  4624.   PAssert(IsDescendant(MCS_TokenAttributes_giving::Class()), PInvalidCast);
  4625. #endif
  4626.   const MCS_TokenAttributes_giving & other = (const MCS_TokenAttributes_giving &)obj;
  4627.  
  4628.   Comparison result;
  4629.  
  4630.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  4631.     return result;
  4632.   if ((result = m_grabber.Compare(other.m_grabber)) != EqualTo)
  4633.     return result;
  4634.   if ((result = m_recipient.Compare(other.m_recipient)) != EqualTo)
  4635.     return result;
  4636.  
  4637.   return PASN_Sequence::Compare(other);
  4638. }
  4639.  
  4640.  
  4641. PINDEX MCS_TokenAttributes_giving::GetDataLength() const
  4642. {
  4643.   PINDEX length = 0;
  4644.   length += m_tokenId.GetObjectLength();
  4645.   length += m_grabber.GetObjectLength();
  4646.   length += m_recipient.GetObjectLength();
  4647.   return length;
  4648. }
  4649.  
  4650.  
  4651. BOOL MCS_TokenAttributes_giving::Decode(PASN_Stream & strm)
  4652. {
  4653.   if (!PreambleDecode(strm))
  4654.     return FALSE;
  4655.  
  4656.   if (!m_tokenId.Decode(strm))
  4657.     return FALSE;
  4658.   if (!m_grabber.Decode(strm))
  4659.     return FALSE;
  4660.   if (!m_recipient.Decode(strm))
  4661.     return FALSE;
  4662.  
  4663.   return UnknownExtensionsDecode(strm);
  4664. }
  4665.  
  4666.  
  4667. void MCS_TokenAttributes_giving::Encode(PASN_Stream & strm) const
  4668. {
  4669.   PreambleEncode(strm);
  4670.  
  4671.   m_tokenId.Encode(strm);
  4672.   m_grabber.Encode(strm);
  4673.   m_recipient.Encode(strm);
  4674.  
  4675.   UnknownExtensionsEncode(strm);
  4676. }
  4677.  
  4678.  
  4679. PObject * MCS_TokenAttributes_giving::Clone() const
  4680. {
  4681. #ifndef PASN_LEANANDMEAN
  4682.   PAssert(IsClass(MCS_TokenAttributes_giving::Class()), PInvalidCast);
  4683. #endif
  4684.   return new MCS_TokenAttributes_giving(*this);
  4685. }
  4686.  
  4687.  
  4688. //
  4689. // TokenAttributes_ungivable
  4690. //
  4691.  
  4692. MCS_TokenAttributes_ungivable::MCS_TokenAttributes_ungivable(unsigned tag, PASN_Object::TagClass tagClass)
  4693.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4694. {
  4695. }
  4696.  
  4697.  
  4698. #ifndef PASN_NOPRINTON
  4699. void MCS_TokenAttributes_ungivable::PrintOn(ostream & strm) const
  4700. {
  4701.   int indent = strm.precision() + 2;
  4702.   strm << "{\n";
  4703.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  4704.   strm << setw(indent+10) << "grabber = " << setprecision(indent) << m_grabber << '\n';
  4705.   strm << setw(indent-1) << "}";
  4706. }
  4707. #endif
  4708.  
  4709.  
  4710. PObject::Comparison MCS_TokenAttributes_ungivable::Compare(const PObject & obj) const
  4711. {
  4712. #ifndef PASN_LEANANDMEAN
  4713.   PAssert(IsDescendant(MCS_TokenAttributes_ungivable::Class()), PInvalidCast);
  4714. #endif
  4715.   const MCS_TokenAttributes_ungivable & other = (const MCS_TokenAttributes_ungivable &)obj;
  4716.  
  4717.   Comparison result;
  4718.  
  4719.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  4720.     return result;
  4721.   if ((result = m_grabber.Compare(other.m_grabber)) != EqualTo)
  4722.     return result;
  4723.  
  4724.   return PASN_Sequence::Compare(other);
  4725. }
  4726.  
  4727.  
  4728. PINDEX MCS_TokenAttributes_ungivable::GetDataLength() const
  4729. {
  4730.   PINDEX length = 0;
  4731.   length += m_tokenId.GetObjectLength();
  4732.   length += m_grabber.GetObjectLength();
  4733.   return length;
  4734. }
  4735.  
  4736.  
  4737. BOOL MCS_TokenAttributes_ungivable::Decode(PASN_Stream & strm)
  4738. {
  4739.   if (!PreambleDecode(strm))
  4740.     return FALSE;
  4741.  
  4742.   if (!m_tokenId.Decode(strm))
  4743.     return FALSE;
  4744.   if (!m_grabber.Decode(strm))
  4745.     return FALSE;
  4746.  
  4747.   return UnknownExtensionsDecode(strm);
  4748. }
  4749.  
  4750.  
  4751. void MCS_TokenAttributes_ungivable::Encode(PASN_Stream & strm) const
  4752. {
  4753.   PreambleEncode(strm);
  4754.  
  4755.   m_tokenId.Encode(strm);
  4756.   m_grabber.Encode(strm);
  4757.  
  4758.   UnknownExtensionsEncode(strm);
  4759. }
  4760.  
  4761.  
  4762. PObject * MCS_TokenAttributes_ungivable::Clone() const
  4763. {
  4764. #ifndef PASN_LEANANDMEAN
  4765.   PAssert(IsClass(MCS_TokenAttributes_ungivable::Class()), PInvalidCast);
  4766. #endif
  4767.   return new MCS_TokenAttributes_ungivable(*this);
  4768. }
  4769.  
  4770.  
  4771. //
  4772. // TokenAttributes_given
  4773. //
  4774.  
  4775. MCS_TokenAttributes_given::MCS_TokenAttributes_given(unsigned tag, PASN_Object::TagClass tagClass)
  4776.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4777. {
  4778. }
  4779.  
  4780.  
  4781. #ifndef PASN_NOPRINTON
  4782. void MCS_TokenAttributes_given::PrintOn(ostream & strm) const
  4783. {
  4784.   int indent = strm.precision() + 2;
  4785.   strm << "{\n";
  4786.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  4787.   strm << setw(indent+12) << "recipient = " << setprecision(indent) << m_recipient << '\n';
  4788.   strm << setw(indent-1) << "}";
  4789. }
  4790. #endif
  4791.  
  4792.  
  4793. PObject::Comparison MCS_TokenAttributes_given::Compare(const PObject & obj) const
  4794. {
  4795. #ifndef PASN_LEANANDMEAN
  4796.   PAssert(IsDescendant(MCS_TokenAttributes_given::Class()), PInvalidCast);
  4797. #endif
  4798.   const MCS_TokenAttributes_given & other = (const MCS_TokenAttributes_given &)obj;
  4799.  
  4800.   Comparison result;
  4801.  
  4802.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  4803.     return result;
  4804.   if ((result = m_recipient.Compare(other.m_recipient)) != EqualTo)
  4805.     return result;
  4806.  
  4807.   return PASN_Sequence::Compare(other);
  4808. }
  4809.  
  4810.  
  4811. PINDEX MCS_TokenAttributes_given::GetDataLength() const
  4812. {
  4813.   PINDEX length = 0;
  4814.   length += m_tokenId.GetObjectLength();
  4815.   length += m_recipient.GetObjectLength();
  4816.   return length;
  4817. }
  4818.  
  4819.  
  4820. BOOL MCS_TokenAttributes_given::Decode(PASN_Stream & strm)
  4821. {
  4822.   if (!PreambleDecode(strm))
  4823.     return FALSE;
  4824.  
  4825.   if (!m_tokenId.Decode(strm))
  4826.     return FALSE;
  4827.   if (!m_recipient.Decode(strm))
  4828.     return FALSE;
  4829.  
  4830.   return UnknownExtensionsDecode(strm);
  4831. }
  4832.  
  4833.  
  4834. void MCS_TokenAttributes_given::Encode(PASN_Stream & strm) const
  4835. {
  4836.   PreambleEncode(strm);
  4837.  
  4838.   m_tokenId.Encode(strm);
  4839.   m_recipient.Encode(strm);
  4840.  
  4841.   UnknownExtensionsEncode(strm);
  4842. }
  4843.  
  4844.  
  4845. PObject * MCS_TokenAttributes_given::Clone() const
  4846. {
  4847. #ifndef PASN_LEANANDMEAN
  4848.   PAssert(IsClass(MCS_TokenAttributes_given::Class()), PInvalidCast);
  4849. #endif
  4850.   return new MCS_TokenAttributes_given(*this);
  4851. }
  4852.  
  4853.  
  4854. //
  4855. // ArrayOf_TokenAttributes
  4856. //
  4857.  
  4858. MCS_ArrayOf_TokenAttributes::MCS_ArrayOf_TokenAttributes(unsigned tag, PASN_Object::TagClass tagClass)
  4859.   : PASN_Array(tag, tagClass)
  4860. {
  4861. }
  4862.  
  4863.  
  4864. PASN_Object * MCS_ArrayOf_TokenAttributes::CreateObject() const
  4865. {
  4866.   return new MCS_TokenAttributes;
  4867. }
  4868.  
  4869.  
  4870. MCS_TokenAttributes & MCS_ArrayOf_TokenAttributes::operator[](PINDEX i) const
  4871. {
  4872.   return (MCS_TokenAttributes &)array[i];
  4873. }
  4874.  
  4875.  
  4876. PObject * MCS_ArrayOf_TokenAttributes::Clone() const
  4877. {
  4878. #ifndef PASN_LEANANDMEAN
  4879.   PAssert(IsClass(MCS_ArrayOf_TokenAttributes::Class()), PInvalidCast);
  4880. #endif
  4881.   return new MCS_ArrayOf_TokenAttributes(*this);
  4882. }
  4883.  
  4884.  
  4885. //
  4886. // ArrayOf_TokenId
  4887. //
  4888.  
  4889. MCS_ArrayOf_TokenId::MCS_ArrayOf_TokenId(unsigned tag, PASN_Object::TagClass tagClass)
  4890.   : PASN_Array(tag, tagClass)
  4891. {
  4892. }
  4893.  
  4894.  
  4895. PASN_Object * MCS_ArrayOf_TokenId::CreateObject() const
  4896. {
  4897.   return new MCS_TokenId;
  4898. }
  4899.  
  4900.  
  4901. MCS_TokenId & MCS_ArrayOf_TokenId::operator[](PINDEX i) const
  4902. {
  4903.   return (MCS_TokenId &)array[i];
  4904. }
  4905.  
  4906.  
  4907. PObject * MCS_ArrayOf_TokenId::Clone() const
  4908. {
  4909. #ifndef PASN_LEANANDMEAN
  4910.   PAssert(IsClass(MCS_ArrayOf_TokenId::Class()), PInvalidCast);
  4911. #endif
  4912.   return new MCS_ArrayOf_TokenId(*this);
  4913. }
  4914.  
  4915.  
  4916. //
  4917. // Connect-Response
  4918. //
  4919.  
  4920. MCS_Connect_Response::MCS_Connect_Response(unsigned tag, PASN_Object::TagClass tagClass)
  4921.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4922. {
  4923.   m_calledConnectId.SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  4924. }
  4925.  
  4926.  
  4927. #ifndef PASN_NOPRINTON
  4928. void MCS_Connect_Response::PrintOn(ostream & strm) const
  4929. {
  4930.   int indent = strm.precision() + 2;
  4931.   strm << "{\n";
  4932.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  4933.   strm << setw(indent+18) << "calledConnectId = " << setprecision(indent) << m_calledConnectId << '\n';
  4934.   strm << setw(indent+19) << "domainParameters = " << setprecision(indent) << m_domainParameters << '\n';
  4935.   strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  4936.   strm << setw(indent-1) << "}";
  4937. }
  4938. #endif
  4939.  
  4940.  
  4941. PObject::Comparison MCS_Connect_Response::Compare(const PObject & obj) const
  4942. {
  4943. #ifndef PASN_LEANANDMEAN
  4944.   PAssert(IsDescendant(MCS_Connect_Response::Class()), PInvalidCast);
  4945. #endif
  4946.   const MCS_Connect_Response & other = (const MCS_Connect_Response &)obj;
  4947.  
  4948.   Comparison result;
  4949.  
  4950.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  4951.     return result;
  4952.   if ((result = m_calledConnectId.Compare(other.m_calledConnectId)) != EqualTo)
  4953.     return result;
  4954.   if ((result = m_domainParameters.Compare(other.m_domainParameters)) != EqualTo)
  4955.     return result;
  4956.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  4957.     return result;
  4958.  
  4959.   return PASN_Sequence::Compare(other);
  4960. }
  4961.  
  4962.  
  4963. PINDEX MCS_Connect_Response::GetDataLength() const
  4964. {
  4965.   PINDEX length = 0;
  4966.   length += m_result.GetObjectLength();
  4967.   length += m_calledConnectId.GetObjectLength();
  4968.   length += m_domainParameters.GetObjectLength();
  4969.   length += m_userData.GetObjectLength();
  4970.   return length;
  4971. }
  4972.  
  4973.  
  4974. BOOL MCS_Connect_Response::Decode(PASN_Stream & strm)
  4975. {
  4976.   if (!PreambleDecode(strm))
  4977.     return FALSE;
  4978.  
  4979.   if (!m_result.Decode(strm))
  4980.     return FALSE;
  4981.   if (!m_calledConnectId.Decode(strm))
  4982.     return FALSE;
  4983.   if (!m_domainParameters.Decode(strm))
  4984.     return FALSE;
  4985.   if (!m_userData.Decode(strm))
  4986.     return FALSE;
  4987.  
  4988.   return UnknownExtensionsDecode(strm);
  4989. }
  4990.  
  4991.  
  4992. void MCS_Connect_Response::Encode(PASN_Stream & strm) const
  4993. {
  4994.   PreambleEncode(strm);
  4995.  
  4996.   m_result.Encode(strm);
  4997.   m_calledConnectId.Encode(strm);
  4998.   m_domainParameters.Encode(strm);
  4999.   m_userData.Encode(strm);
  5000.  
  5001.   UnknownExtensionsEncode(strm);
  5002. }
  5003.  
  5004.  
  5005. PObject * MCS_Connect_Response::Clone() const
  5006. {
  5007. #ifndef PASN_LEANANDMEAN
  5008.   PAssert(IsClass(MCS_Connect_Response::Class()), PInvalidCast);
  5009. #endif
  5010.   return new MCS_Connect_Response(*this);
  5011. }
  5012.  
  5013.  
  5014. //
  5015. // Connect-Result
  5016. //
  5017.  
  5018. MCS_Connect_Result::MCS_Connect_Result(unsigned tag, PASN_Object::TagClass tagClass)
  5019.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5020. {
  5021. }
  5022.  
  5023.  
  5024. #ifndef PASN_NOPRINTON
  5025. void MCS_Connect_Result::PrintOn(ostream & strm) const
  5026. {
  5027.   int indent = strm.precision() + 2;
  5028.   strm << "{\n";
  5029.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  5030.   strm << setw(indent-1) << "}";
  5031. }
  5032. #endif
  5033.  
  5034.  
  5035. PObject::Comparison MCS_Connect_Result::Compare(const PObject & obj) const
  5036. {
  5037. #ifndef PASN_LEANANDMEAN
  5038.   PAssert(IsDescendant(MCS_Connect_Result::Class()), PInvalidCast);
  5039. #endif
  5040.   const MCS_Connect_Result & other = (const MCS_Connect_Result &)obj;
  5041.  
  5042.   Comparison result;
  5043.  
  5044.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  5045.     return result;
  5046.  
  5047.   return PASN_Sequence::Compare(other);
  5048. }
  5049.  
  5050.  
  5051. PINDEX MCS_Connect_Result::GetDataLength() const
  5052. {
  5053.   PINDEX length = 0;
  5054.   length += m_result.GetObjectLength();
  5055.   return length;
  5056. }
  5057.  
  5058.  
  5059. BOOL MCS_Connect_Result::Decode(PASN_Stream & strm)
  5060. {
  5061.   if (!PreambleDecode(strm))
  5062.     return FALSE;
  5063.  
  5064.   if (!m_result.Decode(strm))
  5065.     return FALSE;
  5066.  
  5067.   return UnknownExtensionsDecode(strm);
  5068. }
  5069.  
  5070.  
  5071. void MCS_Connect_Result::Encode(PASN_Stream & strm) const
  5072. {
  5073.   PreambleEncode(strm);
  5074.  
  5075.   m_result.Encode(strm);
  5076.  
  5077.   UnknownExtensionsEncode(strm);
  5078. }
  5079.  
  5080.  
  5081. PObject * MCS_Connect_Result::Clone() const
  5082. {
  5083. #ifndef PASN_LEANANDMEAN
  5084.   PAssert(IsClass(MCS_Connect_Result::Class()), PInvalidCast);
  5085. #endif
  5086.   return new MCS_Connect_Result(*this);
  5087. }
  5088.  
  5089.  
  5090. //
  5091. // MCrq
  5092. //
  5093.  
  5094. MCS_MCrq::MCS_MCrq(unsigned tag, PASN_Object::TagClass tagClass)
  5095.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5096. {
  5097. }
  5098.  
  5099.  
  5100. #ifndef PASN_NOPRINTON
  5101. void MCS_MCrq::PrintOn(ostream & strm) const
  5102. {
  5103.   int indent = strm.precision() + 2;
  5104.   strm << "{\n";
  5105.   strm << setw(indent+16) << "mergeChannels = " << setprecision(indent) << m_mergeChannels << '\n';
  5106.   strm << setw(indent+18) << "purgeChannelIds = " << setprecision(indent) << m_purgeChannelIds << '\n';
  5107.   strm << setw(indent-1) << "}";
  5108. }
  5109. #endif
  5110.  
  5111.  
  5112. PObject::Comparison MCS_MCrq::Compare(const PObject & obj) const
  5113. {
  5114. #ifndef PASN_LEANANDMEAN
  5115.   PAssert(IsDescendant(MCS_MCrq::Class()), PInvalidCast);
  5116. #endif
  5117.   const MCS_MCrq & other = (const MCS_MCrq &)obj;
  5118.  
  5119.   Comparison result;
  5120.  
  5121.   if ((result = m_mergeChannels.Compare(other.m_mergeChannels)) != EqualTo)
  5122.     return result;
  5123.   if ((result = m_purgeChannelIds.Compare(other.m_purgeChannelIds)) != EqualTo)
  5124.     return result;
  5125.  
  5126.   return PASN_Sequence::Compare(other);
  5127. }
  5128.  
  5129.  
  5130. PINDEX MCS_MCrq::GetDataLength() const
  5131. {
  5132.   PINDEX length = 0;
  5133.   length += m_mergeChannels.GetObjectLength();
  5134.   length += m_purgeChannelIds.GetObjectLength();
  5135.   return length;
  5136. }
  5137.  
  5138.  
  5139. BOOL MCS_MCrq::Decode(PASN_Stream & strm)
  5140. {
  5141.   if (!PreambleDecode(strm))
  5142.     return FALSE;
  5143.  
  5144.   if (!m_mergeChannels.Decode(strm))
  5145.     return FALSE;
  5146.   if (!m_purgeChannelIds.Decode(strm))
  5147.     return FALSE;
  5148.  
  5149.   return UnknownExtensionsDecode(strm);
  5150. }
  5151.  
  5152.  
  5153. void MCS_MCrq::Encode(PASN_Stream & strm) const
  5154. {
  5155.   PreambleEncode(strm);
  5156.  
  5157.   m_mergeChannels.Encode(strm);
  5158.   m_purgeChannelIds.Encode(strm);
  5159.  
  5160.   UnknownExtensionsEncode(strm);
  5161. }
  5162.  
  5163.  
  5164. PObject * MCS_MCrq::Clone() const
  5165. {
  5166. #ifndef PASN_LEANANDMEAN
  5167.   PAssert(IsClass(MCS_MCrq::Class()), PInvalidCast);
  5168. #endif
  5169.   return new MCS_MCrq(*this);
  5170. }
  5171.  
  5172.  
  5173. //
  5174. // MCcf
  5175. //
  5176.  
  5177. MCS_MCcf::MCS_MCcf(unsigned tag, PASN_Object::TagClass tagClass)
  5178.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5179. {
  5180. }
  5181.  
  5182.  
  5183. #ifndef PASN_NOPRINTON
  5184. void MCS_MCcf::PrintOn(ostream & strm) const
  5185. {
  5186.   int indent = strm.precision() + 2;
  5187.   strm << "{\n";
  5188.   strm << setw(indent+16) << "mergeChannels = " << setprecision(indent) << m_mergeChannels << '\n';
  5189.   strm << setw(indent+18) << "purgeChannelIds = " << setprecision(indent) << m_purgeChannelIds << '\n';
  5190.   strm << setw(indent-1) << "}";
  5191. }
  5192. #endif
  5193.  
  5194.  
  5195. PObject::Comparison MCS_MCcf::Compare(const PObject & obj) const
  5196. {
  5197. #ifndef PASN_LEANANDMEAN
  5198.   PAssert(IsDescendant(MCS_MCcf::Class()), PInvalidCast);
  5199. #endif
  5200.   const MCS_MCcf & other = (const MCS_MCcf &)obj;
  5201.  
  5202.   Comparison result;
  5203.  
  5204.   if ((result = m_mergeChannels.Compare(other.m_mergeChannels)) != EqualTo)
  5205.     return result;
  5206.   if ((result = m_purgeChannelIds.Compare(other.m_purgeChannelIds)) != EqualTo)
  5207.     return result;
  5208.  
  5209.   return PASN_Sequence::Compare(other);
  5210. }
  5211.  
  5212.  
  5213. PINDEX MCS_MCcf::GetDataLength() const
  5214. {
  5215.   PINDEX length = 0;
  5216.   length += m_mergeChannels.GetObjectLength();
  5217.   length += m_purgeChannelIds.GetObjectLength();
  5218.   return length;
  5219. }
  5220.  
  5221.  
  5222. BOOL MCS_MCcf::Decode(PASN_Stream & strm)
  5223. {
  5224.   if (!PreambleDecode(strm))
  5225.     return FALSE;
  5226.  
  5227.   if (!m_mergeChannels.Decode(strm))
  5228.     return FALSE;
  5229.   if (!m_purgeChannelIds.Decode(strm))
  5230.     return FALSE;
  5231.  
  5232.   return UnknownExtensionsDecode(strm);
  5233. }
  5234.  
  5235.  
  5236. void MCS_MCcf::Encode(PASN_Stream & strm) const
  5237. {
  5238.   PreambleEncode(strm);
  5239.  
  5240.   m_mergeChannels.Encode(strm);
  5241.   m_purgeChannelIds.Encode(strm);
  5242.  
  5243.   UnknownExtensionsEncode(strm);
  5244. }
  5245.  
  5246.  
  5247. PObject * MCS_MCcf::Clone() const
  5248. {
  5249. #ifndef PASN_LEANANDMEAN
  5250.   PAssert(IsClass(MCS_MCcf::Class()), PInvalidCast);
  5251. #endif
  5252.   return new MCS_MCcf(*this);
  5253. }
  5254.  
  5255.  
  5256. //
  5257. // PCin
  5258. //
  5259.  
  5260. MCS_PCin::MCS_PCin(unsigned tag, PASN_Object::TagClass tagClass)
  5261.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5262. {
  5263. }
  5264.  
  5265.  
  5266. #ifndef PASN_NOPRINTON
  5267. void MCS_PCin::PrintOn(ostream & strm) const
  5268. {
  5269.   int indent = strm.precision() + 2;
  5270.   strm << "{\n";
  5271.   strm << setw(indent+16) << "detachUserIds = " << setprecision(indent) << m_detachUserIds << '\n';
  5272.   strm << setw(indent+18) << "purgeChannelIds = " << setprecision(indent) << m_purgeChannelIds << '\n';
  5273.   strm << setw(indent-1) << "}";
  5274. }
  5275. #endif
  5276.  
  5277.  
  5278. PObject::Comparison MCS_PCin::Compare(const PObject & obj) const
  5279. {
  5280. #ifndef PASN_LEANANDMEAN
  5281.   PAssert(IsDescendant(MCS_PCin::Class()), PInvalidCast);
  5282. #endif
  5283.   const MCS_PCin & other = (const MCS_PCin &)obj;
  5284.  
  5285.   Comparison result;
  5286.  
  5287.   if ((result = m_detachUserIds.Compare(other.m_detachUserIds)) != EqualTo)
  5288.     return result;
  5289.   if ((result = m_purgeChannelIds.Compare(other.m_purgeChannelIds)) != EqualTo)
  5290.     return result;
  5291.  
  5292.   return PASN_Sequence::Compare(other);
  5293. }
  5294.  
  5295.  
  5296. PINDEX MCS_PCin::GetDataLength() const
  5297. {
  5298.   PINDEX length = 0;
  5299.   length += m_detachUserIds.GetObjectLength();
  5300.   length += m_purgeChannelIds.GetObjectLength();
  5301.   return length;
  5302. }
  5303.  
  5304.  
  5305. BOOL MCS_PCin::Decode(PASN_Stream & strm)
  5306. {
  5307.   if (!PreambleDecode(strm))
  5308.     return FALSE;
  5309.  
  5310.   if (!m_detachUserIds.Decode(strm))
  5311.     return FALSE;
  5312.   if (!m_purgeChannelIds.Decode(strm))
  5313.     return FALSE;
  5314.  
  5315.   return UnknownExtensionsDecode(strm);
  5316. }
  5317.  
  5318.  
  5319. void MCS_PCin::Encode(PASN_Stream & strm) const
  5320. {
  5321.   PreambleEncode(strm);
  5322.  
  5323.   m_detachUserIds.Encode(strm);
  5324.   m_purgeChannelIds.Encode(strm);
  5325.  
  5326.   UnknownExtensionsEncode(strm);
  5327. }
  5328.  
  5329.  
  5330. PObject * MCS_PCin::Clone() const
  5331. {
  5332. #ifndef PASN_LEANANDMEAN
  5333.   PAssert(IsClass(MCS_PCin::Class()), PInvalidCast);
  5334. #endif
  5335.   return new MCS_PCin(*this);
  5336. }
  5337.  
  5338.  
  5339. //
  5340. // MTrq
  5341. //
  5342.  
  5343. MCS_MTrq::MCS_MTrq(unsigned tag, PASN_Object::TagClass tagClass)
  5344.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5345. {
  5346. }
  5347.  
  5348.  
  5349. #ifndef PASN_NOPRINTON
  5350. void MCS_MTrq::PrintOn(ostream & strm) const
  5351. {
  5352.   int indent = strm.precision() + 2;
  5353.   strm << "{\n";
  5354.   strm << setw(indent+14) << "mergeTokens = " << setprecision(indent) << m_mergeTokens << '\n';
  5355.   strm << setw(indent+16) << "purgeTokenIds = " << setprecision(indent) << m_purgeTokenIds << '\n';
  5356.   strm << setw(indent-1) << "}";
  5357. }
  5358. #endif
  5359.  
  5360.  
  5361. PObject::Comparison MCS_MTrq::Compare(const PObject & obj) const
  5362. {
  5363. #ifndef PASN_LEANANDMEAN
  5364.   PAssert(IsDescendant(MCS_MTrq::Class()), PInvalidCast);
  5365. #endif
  5366.   const MCS_MTrq & other = (const MCS_MTrq &)obj;
  5367.  
  5368.   Comparison result;
  5369.  
  5370.   if ((result = m_mergeTokens.Compare(other.m_mergeTokens)) != EqualTo)
  5371.     return result;
  5372.   if ((result = m_purgeTokenIds.Compare(other.m_purgeTokenIds)) != EqualTo)
  5373.     return result;
  5374.  
  5375.   return PASN_Sequence::Compare(other);
  5376. }
  5377.  
  5378.  
  5379. PINDEX MCS_MTrq::GetDataLength() const
  5380. {
  5381.   PINDEX length = 0;
  5382.   length += m_mergeTokens.GetObjectLength();
  5383.   length += m_purgeTokenIds.GetObjectLength();
  5384.   return length;
  5385. }
  5386.  
  5387.  
  5388. BOOL MCS_MTrq::Decode(PASN_Stream & strm)
  5389. {
  5390.   if (!PreambleDecode(strm))
  5391.     return FALSE;
  5392.  
  5393.   if (!m_mergeTokens.Decode(strm))
  5394.     return FALSE;
  5395.   if (!m_purgeTokenIds.Decode(strm))
  5396.     return FALSE;
  5397.  
  5398.   return UnknownExtensionsDecode(strm);
  5399. }
  5400.  
  5401.  
  5402. void MCS_MTrq::Encode(PASN_Stream & strm) const
  5403. {
  5404.   PreambleEncode(strm);
  5405.  
  5406.   m_mergeTokens.Encode(strm);
  5407.   m_purgeTokenIds.Encode(strm);
  5408.  
  5409.   UnknownExtensionsEncode(strm);
  5410. }
  5411.  
  5412.  
  5413. PObject * MCS_MTrq::Clone() const
  5414. {
  5415. #ifndef PASN_LEANANDMEAN
  5416.   PAssert(IsClass(MCS_MTrq::Class()), PInvalidCast);
  5417. #endif
  5418.   return new MCS_MTrq(*this);
  5419. }
  5420.  
  5421.  
  5422. //
  5423. // MTcf
  5424. //
  5425.  
  5426. MCS_MTcf::MCS_MTcf(unsigned tag, PASN_Object::TagClass tagClass)
  5427.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5428. {
  5429. }
  5430.  
  5431.  
  5432. #ifndef PASN_NOPRINTON
  5433. void MCS_MTcf::PrintOn(ostream & strm) const
  5434. {
  5435.   int indent = strm.precision() + 2;
  5436.   strm << "{\n";
  5437.   strm << setw(indent+14) << "mergeTokens = " << setprecision(indent) << m_mergeTokens << '\n';
  5438.   strm << setw(indent+16) << "purgeTokenIds = " << setprecision(indent) << m_purgeTokenIds << '\n';
  5439.   strm << setw(indent-1) << "}";
  5440. }
  5441. #endif
  5442.  
  5443.  
  5444. PObject::Comparison MCS_MTcf::Compare(const PObject & obj) const
  5445. {
  5446. #ifndef PASN_LEANANDMEAN
  5447.   PAssert(IsDescendant(MCS_MTcf::Class()), PInvalidCast);
  5448. #endif
  5449.   const MCS_MTcf & other = (const MCS_MTcf &)obj;
  5450.  
  5451.   Comparison result;
  5452.  
  5453.   if ((result = m_mergeTokens.Compare(other.m_mergeTokens)) != EqualTo)
  5454.     return result;
  5455.   if ((result = m_purgeTokenIds.Compare(other.m_purgeTokenIds)) != EqualTo)
  5456.     return result;
  5457.  
  5458.   return PASN_Sequence::Compare(other);
  5459. }
  5460.  
  5461.  
  5462. PINDEX MCS_MTcf::GetDataLength() const
  5463. {
  5464.   PINDEX length = 0;
  5465.   length += m_mergeTokens.GetObjectLength();
  5466.   length += m_purgeTokenIds.GetObjectLength();
  5467.   return length;
  5468. }
  5469.  
  5470.  
  5471. BOOL MCS_MTcf::Decode(PASN_Stream & strm)
  5472. {
  5473.   if (!PreambleDecode(strm))
  5474.     return FALSE;
  5475.  
  5476.   if (!m_mergeTokens.Decode(strm))
  5477.     return FALSE;
  5478.   if (!m_purgeTokenIds.Decode(strm))
  5479.     return FALSE;
  5480.  
  5481.   return UnknownExtensionsDecode(strm);
  5482. }
  5483.  
  5484.  
  5485. void MCS_MTcf::Encode(PASN_Stream & strm) const
  5486. {
  5487.   PreambleEncode(strm);
  5488.  
  5489.   m_mergeTokens.Encode(strm);
  5490.   m_purgeTokenIds.Encode(strm);
  5491.  
  5492.   UnknownExtensionsEncode(strm);
  5493. }
  5494.  
  5495.  
  5496. PObject * MCS_MTcf::Clone() const
  5497. {
  5498. #ifndef PASN_LEANANDMEAN
  5499.   PAssert(IsClass(MCS_MTcf::Class()), PInvalidCast);
  5500. #endif
  5501.   return new MCS_MTcf(*this);
  5502. }
  5503.  
  5504.  
  5505. //
  5506. // PTin
  5507. //
  5508.  
  5509. MCS_PTin::MCS_PTin(unsigned tag, PASN_Object::TagClass tagClass)
  5510.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5511. {
  5512. }
  5513.  
  5514.  
  5515. #ifndef PASN_NOPRINTON
  5516. void MCS_PTin::PrintOn(ostream & strm) const
  5517. {
  5518.   int indent = strm.precision() + 2;
  5519.   strm << "{\n";
  5520.   strm << setw(indent+16) << "purgeTokenIds = " << setprecision(indent) << m_purgeTokenIds << '\n';
  5521.   strm << setw(indent-1) << "}";
  5522. }
  5523. #endif
  5524.  
  5525.  
  5526. PObject::Comparison MCS_PTin::Compare(const PObject & obj) const
  5527. {
  5528. #ifndef PASN_LEANANDMEAN
  5529.   PAssert(IsDescendant(MCS_PTin::Class()), PInvalidCast);
  5530. #endif
  5531.   const MCS_PTin & other = (const MCS_PTin &)obj;
  5532.  
  5533.   Comparison result;
  5534.  
  5535.   if ((result = m_purgeTokenIds.Compare(other.m_purgeTokenIds)) != EqualTo)
  5536.     return result;
  5537.  
  5538.   return PASN_Sequence::Compare(other);
  5539. }
  5540.  
  5541.  
  5542. PINDEX MCS_PTin::GetDataLength() const
  5543. {
  5544.   PINDEX length = 0;
  5545.   length += m_purgeTokenIds.GetObjectLength();
  5546.   return length;
  5547. }
  5548.  
  5549.  
  5550. BOOL MCS_PTin::Decode(PASN_Stream & strm)
  5551. {
  5552.   if (!PreambleDecode(strm))
  5553.     return FALSE;
  5554.  
  5555.   if (!m_purgeTokenIds.Decode(strm))
  5556.     return FALSE;
  5557.  
  5558.   return UnknownExtensionsDecode(strm);
  5559. }
  5560.  
  5561.  
  5562. void MCS_PTin::Encode(PASN_Stream & strm) const
  5563. {
  5564.   PreambleEncode(strm);
  5565.  
  5566.   m_purgeTokenIds.Encode(strm);
  5567.  
  5568.   UnknownExtensionsEncode(strm);
  5569. }
  5570.  
  5571.  
  5572. PObject * MCS_PTin::Clone() const
  5573. {
  5574. #ifndef PASN_LEANANDMEAN
  5575.   PAssert(IsClass(MCS_PTin::Class()), PInvalidCast);
  5576. #endif
  5577.   return new MCS_PTin(*this);
  5578. }
  5579.  
  5580.  
  5581. //
  5582. // DPum
  5583. //
  5584.  
  5585. MCS_DPum::MCS_DPum(unsigned tag, PASN_Object::TagClass tagClass)
  5586.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5587. {
  5588. }
  5589.  
  5590.  
  5591. #ifndef PASN_NOPRINTON
  5592. void MCS_DPum::PrintOn(ostream & strm) const
  5593. {
  5594.   int indent = strm.precision() + 2;
  5595.   strm << "{\n";
  5596.   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  5597.   strm << setw(indent-1) << "}";
  5598. }
  5599. #endif
  5600.  
  5601.  
  5602. PObject::Comparison MCS_DPum::Compare(const PObject & obj) const
  5603. {
  5604. #ifndef PASN_LEANANDMEAN
  5605.   PAssert(IsDescendant(MCS_DPum::Class()), PInvalidCast);
  5606. #endif
  5607.   const MCS_DPum & other = (const MCS_DPum &)obj;
  5608.  
  5609.   Comparison result;
  5610.  
  5611.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  5612.     return result;
  5613.  
  5614.   return PASN_Sequence::Compare(other);
  5615. }
  5616.  
  5617.  
  5618. PINDEX MCS_DPum::GetDataLength() const
  5619. {
  5620.   PINDEX length = 0;
  5621.   length += m_reason.GetObjectLength();
  5622.   return length;
  5623. }
  5624.  
  5625.  
  5626. BOOL MCS_DPum::Decode(PASN_Stream & strm)
  5627. {
  5628.   if (!PreambleDecode(strm))
  5629.     return FALSE;
  5630.  
  5631.   if (!m_reason.Decode(strm))
  5632.     return FALSE;
  5633.  
  5634.   return UnknownExtensionsDecode(strm);
  5635. }
  5636.  
  5637.  
  5638. void MCS_DPum::Encode(PASN_Stream & strm) const
  5639. {
  5640.   PreambleEncode(strm);
  5641.  
  5642.   m_reason.Encode(strm);
  5643.  
  5644.   UnknownExtensionsEncode(strm);
  5645. }
  5646.  
  5647.  
  5648. PObject * MCS_DPum::Clone() const
  5649. {
  5650. #ifndef PASN_LEANANDMEAN
  5651.   PAssert(IsClass(MCS_DPum::Class()), PInvalidCast);
  5652. #endif
  5653.   return new MCS_DPum(*this);
  5654. }
  5655.  
  5656.  
  5657. //
  5658. // RJum
  5659. //
  5660.  
  5661. MCS_RJum::MCS_RJum(unsigned tag, PASN_Object::TagClass tagClass)
  5662.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5663. {
  5664. }
  5665.  
  5666.  
  5667. #ifndef PASN_NOPRINTON
  5668. void MCS_RJum::PrintOn(ostream & strm) const
  5669. {
  5670.   int indent = strm.precision() + 2;
  5671.   strm << "{\n";
  5672.   strm << setw(indent+13) << "diagnostic = " << setprecision(indent) << m_diagnostic << '\n';
  5673.   strm << setw(indent+16) << "initialOctets = " << setprecision(indent) << m_initialOctets << '\n';
  5674.   strm << setw(indent-1) << "}";
  5675. }
  5676. #endif
  5677.  
  5678.  
  5679. PObject::Comparison MCS_RJum::Compare(const PObject & obj) const
  5680. {
  5681. #ifndef PASN_LEANANDMEAN
  5682.   PAssert(IsDescendant(MCS_RJum::Class()), PInvalidCast);
  5683. #endif
  5684.   const MCS_RJum & other = (const MCS_RJum &)obj;
  5685.  
  5686.   Comparison result;
  5687.  
  5688.   if ((result = m_diagnostic.Compare(other.m_diagnostic)) != EqualTo)
  5689.     return result;
  5690.   if ((result = m_initialOctets.Compare(other.m_initialOctets)) != EqualTo)
  5691.     return result;
  5692.  
  5693.   return PASN_Sequence::Compare(other);
  5694. }
  5695.  
  5696.  
  5697. PINDEX MCS_RJum::GetDataLength() const
  5698. {
  5699.   PINDEX length = 0;
  5700.   length += m_diagnostic.GetObjectLength();
  5701.   length += m_initialOctets.GetObjectLength();
  5702.   return length;
  5703. }
  5704.  
  5705.  
  5706. BOOL MCS_RJum::Decode(PASN_Stream & strm)
  5707. {
  5708.   if (!PreambleDecode(strm))
  5709.     return FALSE;
  5710.  
  5711.   if (!m_diagnostic.Decode(strm))
  5712.     return FALSE;
  5713.   if (!m_initialOctets.Decode(strm))
  5714.     return FALSE;
  5715.  
  5716.   return UnknownExtensionsDecode(strm);
  5717. }
  5718.  
  5719.  
  5720. void MCS_RJum::Encode(PASN_Stream & strm) const
  5721. {
  5722.   PreambleEncode(strm);
  5723.  
  5724.   m_diagnostic.Encode(strm);
  5725.   m_initialOctets.Encode(strm);
  5726.  
  5727.   UnknownExtensionsEncode(strm);
  5728. }
  5729.  
  5730.  
  5731. PObject * MCS_RJum::Clone() const
  5732. {
  5733. #ifndef PASN_LEANANDMEAN
  5734.   PAssert(IsClass(MCS_RJum::Class()), PInvalidCast);
  5735. #endif
  5736.   return new MCS_RJum(*this);
  5737. }
  5738.  
  5739.  
  5740. //
  5741. // AUcf
  5742. //
  5743.  
  5744. MCS_AUcf::MCS_AUcf(unsigned tag, PASN_Object::TagClass tagClass)
  5745.   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
  5746. {
  5747. }
  5748.  
  5749.  
  5750. #ifndef PASN_NOPRINTON
  5751. void MCS_AUcf::PrintOn(ostream & strm) const
  5752. {
  5753.   int indent = strm.precision() + 2;
  5754.   strm << "{\n";
  5755.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  5756.   if (HasOptionalField(e_initiator))
  5757.     strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  5758.   strm << setw(indent-1) << "}";
  5759. }
  5760. #endif
  5761.  
  5762.  
  5763. PObject::Comparison MCS_AUcf::Compare(const PObject & obj) const
  5764. {
  5765. #ifndef PASN_LEANANDMEAN
  5766.   PAssert(IsDescendant(MCS_AUcf::Class()), PInvalidCast);
  5767. #endif
  5768.   const MCS_AUcf & other = (const MCS_AUcf &)obj;
  5769.  
  5770.   Comparison result;
  5771.  
  5772.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  5773.     return result;
  5774.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  5775.     return result;
  5776.  
  5777.   return PASN_Sequence::Compare(other);
  5778. }
  5779.  
  5780.  
  5781. PINDEX MCS_AUcf::GetDataLength() const
  5782. {
  5783.   PINDEX length = 0;
  5784.   length += m_result.GetObjectLength();
  5785.   if (HasOptionalField(e_initiator))
  5786.     length += m_initiator.GetObjectLength();
  5787.   return length;
  5788. }
  5789.  
  5790.  
  5791. BOOL MCS_AUcf::Decode(PASN_Stream & strm)
  5792. {
  5793.   if (!PreambleDecode(strm))
  5794.     return FALSE;
  5795.  
  5796.   if (!m_result.Decode(strm))
  5797.     return FALSE;
  5798.   if (HasOptionalField(e_initiator) && !m_initiator.Decode(strm))
  5799.     return FALSE;
  5800.  
  5801.   return UnknownExtensionsDecode(strm);
  5802. }
  5803.  
  5804.  
  5805. void MCS_AUcf::Encode(PASN_Stream & strm) const
  5806. {
  5807.   PreambleEncode(strm);
  5808.  
  5809.   m_result.Encode(strm);
  5810.   if (HasOptionalField(e_initiator))
  5811.     m_initiator.Encode(strm);
  5812.  
  5813.   UnknownExtensionsEncode(strm);
  5814. }
  5815.  
  5816.  
  5817. PObject * MCS_AUcf::Clone() const
  5818. {
  5819. #ifndef PASN_LEANANDMEAN
  5820.   PAssert(IsClass(MCS_AUcf::Class()), PInvalidCast);
  5821. #endif
  5822.   return new MCS_AUcf(*this);
  5823. }
  5824.  
  5825.  
  5826. //
  5827. // DUrq
  5828. //
  5829.  
  5830. MCS_DUrq::MCS_DUrq(unsigned tag, PASN_Object::TagClass tagClass)
  5831.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5832. {
  5833. }
  5834.  
  5835.  
  5836. #ifndef PASN_NOPRINTON
  5837. void MCS_DUrq::PrintOn(ostream & strm) const
  5838. {
  5839.   int indent = strm.precision() + 2;
  5840.   strm << "{\n";
  5841.   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  5842.   strm << setw(indent+10) << "userIds = " << setprecision(indent) << m_userIds << '\n';
  5843.   strm << setw(indent-1) << "}";
  5844. }
  5845. #endif
  5846.  
  5847.  
  5848. PObject::Comparison MCS_DUrq::Compare(const PObject & obj) const
  5849. {
  5850. #ifndef PASN_LEANANDMEAN
  5851.   PAssert(IsDescendant(MCS_DUrq::Class()), PInvalidCast);
  5852. #endif
  5853.   const MCS_DUrq & other = (const MCS_DUrq &)obj;
  5854.  
  5855.   Comparison result;
  5856.  
  5857.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  5858.     return result;
  5859.   if ((result = m_userIds.Compare(other.m_userIds)) != EqualTo)
  5860.     return result;
  5861.  
  5862.   return PASN_Sequence::Compare(other);
  5863. }
  5864.  
  5865.  
  5866. PINDEX MCS_DUrq::GetDataLength() const
  5867. {
  5868.   PINDEX length = 0;
  5869.   length += m_reason.GetObjectLength();
  5870.   length += m_userIds.GetObjectLength();
  5871.   return length;
  5872. }
  5873.  
  5874.  
  5875. BOOL MCS_DUrq::Decode(PASN_Stream & strm)
  5876. {
  5877.   if (!PreambleDecode(strm))
  5878.     return FALSE;
  5879.  
  5880.   if (!m_reason.Decode(strm))
  5881.     return FALSE;
  5882.   if (!m_userIds.Decode(strm))
  5883.     return FALSE;
  5884.  
  5885.   return UnknownExtensionsDecode(strm);
  5886. }
  5887.  
  5888.  
  5889. void MCS_DUrq::Encode(PASN_Stream & strm) const
  5890. {
  5891.   PreambleEncode(strm);
  5892.  
  5893.   m_reason.Encode(strm);
  5894.   m_userIds.Encode(strm);
  5895.  
  5896.   UnknownExtensionsEncode(strm);
  5897. }
  5898.  
  5899.  
  5900. PObject * MCS_DUrq::Clone() const
  5901. {
  5902. #ifndef PASN_LEANANDMEAN
  5903.   PAssert(IsClass(MCS_DUrq::Class()), PInvalidCast);
  5904. #endif
  5905.   return new MCS_DUrq(*this);
  5906. }
  5907.  
  5908.  
  5909. //
  5910. // DUin
  5911. //
  5912.  
  5913. MCS_DUin::MCS_DUin(unsigned tag, PASN_Object::TagClass tagClass)
  5914.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  5915. {
  5916. }
  5917.  
  5918.  
  5919. #ifndef PASN_NOPRINTON
  5920. void MCS_DUin::PrintOn(ostream & strm) const
  5921. {
  5922.   int indent = strm.precision() + 2;
  5923.   strm << "{\n";
  5924.   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  5925.   strm << setw(indent+10) << "userIds = " << setprecision(indent) << m_userIds << '\n';
  5926.   strm << setw(indent-1) << "}";
  5927. }
  5928. #endif
  5929.  
  5930.  
  5931. PObject::Comparison MCS_DUin::Compare(const PObject & obj) const
  5932. {
  5933. #ifndef PASN_LEANANDMEAN
  5934.   PAssert(IsDescendant(MCS_DUin::Class()), PInvalidCast);
  5935. #endif
  5936.   const MCS_DUin & other = (const MCS_DUin &)obj;
  5937.  
  5938.   Comparison result;
  5939.  
  5940.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  5941.     return result;
  5942.   if ((result = m_userIds.Compare(other.m_userIds)) != EqualTo)
  5943.     return result;
  5944.  
  5945.   return PASN_Sequence::Compare(other);
  5946. }
  5947.  
  5948.  
  5949. PINDEX MCS_DUin::GetDataLength() const
  5950. {
  5951.   PINDEX length = 0;
  5952.   length += m_reason.GetObjectLength();
  5953.   length += m_userIds.GetObjectLength();
  5954.   return length;
  5955. }
  5956.  
  5957.  
  5958. BOOL MCS_DUin::Decode(PASN_Stream & strm)
  5959. {
  5960.   if (!PreambleDecode(strm))
  5961.     return FALSE;
  5962.  
  5963.   if (!m_reason.Decode(strm))
  5964.     return FALSE;
  5965.   if (!m_userIds.Decode(strm))
  5966.     return FALSE;
  5967.  
  5968.   return UnknownExtensionsDecode(strm);
  5969. }
  5970.  
  5971.  
  5972. void MCS_DUin::Encode(PASN_Stream & strm) const
  5973. {
  5974.   PreambleEncode(strm);
  5975.  
  5976.   m_reason.Encode(strm);
  5977.   m_userIds.Encode(strm);
  5978.  
  5979.   UnknownExtensionsEncode(strm);
  5980. }
  5981.  
  5982.  
  5983. PObject * MCS_DUin::Clone() const
  5984. {
  5985. #ifndef PASN_LEANANDMEAN
  5986.   PAssert(IsClass(MCS_DUin::Class()), PInvalidCast);
  5987. #endif
  5988.   return new MCS_DUin(*this);
  5989. }
  5990.  
  5991.  
  5992. //
  5993. // CJcf
  5994. //
  5995.  
  5996. MCS_CJcf::MCS_CJcf(unsigned tag, PASN_Object::TagClass tagClass)
  5997.   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
  5998. {
  5999. }
  6000.  
  6001.  
  6002. #ifndef PASN_NOPRINTON
  6003. void MCS_CJcf::PrintOn(ostream & strm) const
  6004. {
  6005.   int indent = strm.precision() + 2;
  6006.   strm << "{\n";
  6007.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  6008.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  6009.   strm << setw(indent+12) << "requested = " << setprecision(indent) << m_requested << '\n';
  6010.   if (HasOptionalField(e_channelId))
  6011.     strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  6012.   strm << setw(indent-1) << "}";
  6013. }
  6014. #endif
  6015.  
  6016.  
  6017. PObject::Comparison MCS_CJcf::Compare(const PObject & obj) const
  6018. {
  6019. #ifndef PASN_LEANANDMEAN
  6020.   PAssert(IsDescendant(MCS_CJcf::Class()), PInvalidCast);
  6021. #endif
  6022.   const MCS_CJcf & other = (const MCS_CJcf &)obj;
  6023.  
  6024.   Comparison result;
  6025.  
  6026.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  6027.     return result;
  6028.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  6029.     return result;
  6030.   if ((result = m_requested.Compare(other.m_requested)) != EqualTo)
  6031.     return result;
  6032.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  6033.     return result;
  6034.  
  6035.   return PASN_Sequence::Compare(other);
  6036. }
  6037.  
  6038.  
  6039. PINDEX MCS_CJcf::GetDataLength() const
  6040. {
  6041.   PINDEX length = 0;
  6042.   length += m_result.GetObjectLength();
  6043.   length += m_initiator.GetObjectLength();
  6044.   length += m_requested.GetObjectLength();
  6045.   if (HasOptionalField(e_channelId))
  6046.     length += m_channelId.GetObjectLength();
  6047.   return length;
  6048. }
  6049.  
  6050.  
  6051. BOOL MCS_CJcf::Decode(PASN_Stream & strm)
  6052. {
  6053.   if (!PreambleDecode(strm))
  6054.     return FALSE;
  6055.  
  6056.   if (!m_result.Decode(strm))
  6057.     return FALSE;
  6058.   if (!m_initiator.Decode(strm))
  6059.     return FALSE;
  6060.   if (!m_requested.Decode(strm))
  6061.     return FALSE;
  6062.   if (HasOptionalField(e_channelId) && !m_channelId.Decode(strm))
  6063.     return FALSE;
  6064.  
  6065.   return UnknownExtensionsDecode(strm);
  6066. }
  6067.  
  6068.  
  6069. void MCS_CJcf::Encode(PASN_Stream & strm) const
  6070. {
  6071.   PreambleEncode(strm);
  6072.  
  6073.   m_result.Encode(strm);
  6074.   m_initiator.Encode(strm);
  6075.   m_requested.Encode(strm);
  6076.   if (HasOptionalField(e_channelId))
  6077.     m_channelId.Encode(strm);
  6078.  
  6079.   UnknownExtensionsEncode(strm);
  6080. }
  6081.  
  6082.  
  6083. PObject * MCS_CJcf::Clone() const
  6084. {
  6085. #ifndef PASN_LEANANDMEAN
  6086.   PAssert(IsClass(MCS_CJcf::Class()), PInvalidCast);
  6087. #endif
  6088.   return new MCS_CJcf(*this);
  6089. }
  6090.  
  6091.  
  6092. //
  6093. // CLrq
  6094. //
  6095.  
  6096. MCS_CLrq::MCS_CLrq(unsigned tag, PASN_Object::TagClass tagClass)
  6097.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6098. {
  6099. }
  6100.  
  6101.  
  6102. #ifndef PASN_NOPRINTON
  6103. void MCS_CLrq::PrintOn(ostream & strm) const
  6104. {
  6105.   int indent = strm.precision() + 2;
  6106.   strm << "{\n";
  6107.   strm << setw(indent+13) << "channelIds = " << setprecision(indent) << m_channelIds << '\n';
  6108.   strm << setw(indent-1) << "}";
  6109. }
  6110. #endif
  6111.  
  6112.  
  6113. PObject::Comparison MCS_CLrq::Compare(const PObject & obj) const
  6114. {
  6115. #ifndef PASN_LEANANDMEAN
  6116.   PAssert(IsDescendant(MCS_CLrq::Class()), PInvalidCast);
  6117. #endif
  6118.   const MCS_CLrq & other = (const MCS_CLrq &)obj;
  6119.  
  6120.   Comparison result;
  6121.  
  6122.   if ((result = m_channelIds.Compare(other.m_channelIds)) != EqualTo)
  6123.     return result;
  6124.  
  6125.   return PASN_Sequence::Compare(other);
  6126. }
  6127.  
  6128.  
  6129. PINDEX MCS_CLrq::GetDataLength() const
  6130. {
  6131.   PINDEX length = 0;
  6132.   length += m_channelIds.GetObjectLength();
  6133.   return length;
  6134. }
  6135.  
  6136.  
  6137. BOOL MCS_CLrq::Decode(PASN_Stream & strm)
  6138. {
  6139.   if (!PreambleDecode(strm))
  6140.     return FALSE;
  6141.  
  6142.   if (!m_channelIds.Decode(strm))
  6143.     return FALSE;
  6144.  
  6145.   return UnknownExtensionsDecode(strm);
  6146. }
  6147.  
  6148.  
  6149. void MCS_CLrq::Encode(PASN_Stream & strm) const
  6150. {
  6151.   PreambleEncode(strm);
  6152.  
  6153.   m_channelIds.Encode(strm);
  6154.  
  6155.   UnknownExtensionsEncode(strm);
  6156. }
  6157.  
  6158.  
  6159. PObject * MCS_CLrq::Clone() const
  6160. {
  6161. #ifndef PASN_LEANANDMEAN
  6162.   PAssert(IsClass(MCS_CLrq::Class()), PInvalidCast);
  6163. #endif
  6164.   return new MCS_CLrq(*this);
  6165. }
  6166.  
  6167.  
  6168. //
  6169. // CCcf
  6170. //
  6171.  
  6172. MCS_CCcf::MCS_CCcf(unsigned tag, PASN_Object::TagClass tagClass)
  6173.   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
  6174. {
  6175. }
  6176.  
  6177.  
  6178. #ifndef PASN_NOPRINTON
  6179. void MCS_CCcf::PrintOn(ostream & strm) const
  6180. {
  6181.   int indent = strm.precision() + 2;
  6182.   strm << "{\n";
  6183.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  6184.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  6185.   if (HasOptionalField(e_channelId))
  6186.     strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  6187.   strm << setw(indent-1) << "}";
  6188. }
  6189. #endif
  6190.  
  6191.  
  6192. PObject::Comparison MCS_CCcf::Compare(const PObject & obj) const
  6193. {
  6194. #ifndef PASN_LEANANDMEAN
  6195.   PAssert(IsDescendant(MCS_CCcf::Class()), PInvalidCast);
  6196. #endif
  6197.   const MCS_CCcf & other = (const MCS_CCcf &)obj;
  6198.  
  6199.   Comparison result;
  6200.  
  6201.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  6202.     return result;
  6203.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  6204.     return result;
  6205.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  6206.     return result;
  6207.  
  6208.   return PASN_Sequence::Compare(other);
  6209. }
  6210.  
  6211.  
  6212. PINDEX MCS_CCcf::GetDataLength() const
  6213. {
  6214.   PINDEX length = 0;
  6215.   length += m_result.GetObjectLength();
  6216.   length += m_initiator.GetObjectLength();
  6217.   if (HasOptionalField(e_channelId))
  6218.     length += m_channelId.GetObjectLength();
  6219.   return length;
  6220. }
  6221.  
  6222.  
  6223. BOOL MCS_CCcf::Decode(PASN_Stream & strm)
  6224. {
  6225.   if (!PreambleDecode(strm))
  6226.     return FALSE;
  6227.  
  6228.   if (!m_result.Decode(strm))
  6229.     return FALSE;
  6230.   if (!m_initiator.Decode(strm))
  6231.     return FALSE;
  6232.   if (HasOptionalField(e_channelId) && !m_channelId.Decode(strm))
  6233.     return FALSE;
  6234.  
  6235.   return UnknownExtensionsDecode(strm);
  6236. }
  6237.  
  6238.  
  6239. void MCS_CCcf::Encode(PASN_Stream & strm) const
  6240. {
  6241.   PreambleEncode(strm);
  6242.  
  6243.   m_result.Encode(strm);
  6244.   m_initiator.Encode(strm);
  6245.   if (HasOptionalField(e_channelId))
  6246.     m_channelId.Encode(strm);
  6247.  
  6248.   UnknownExtensionsEncode(strm);
  6249. }
  6250.  
  6251.  
  6252. PObject * MCS_CCcf::Clone() const
  6253. {
  6254. #ifndef PASN_LEANANDMEAN
  6255.   PAssert(IsClass(MCS_CCcf::Class()), PInvalidCast);
  6256. #endif
  6257.   return new MCS_CCcf(*this);
  6258. }
  6259.  
  6260.  
  6261. //
  6262. // CArq
  6263. //
  6264.  
  6265. MCS_CArq::MCS_CArq(unsigned tag, PASN_Object::TagClass tagClass)
  6266.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6267. {
  6268. }
  6269.  
  6270.  
  6271. #ifndef PASN_NOPRINTON
  6272. void MCS_CArq::PrintOn(ostream & strm) const
  6273. {
  6274.   int indent = strm.precision() + 2;
  6275.   strm << "{\n";
  6276.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  6277.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  6278.   strm << setw(indent+10) << "userIds = " << setprecision(indent) << m_userIds << '\n';
  6279.   strm << setw(indent-1) << "}";
  6280. }
  6281. #endif
  6282.  
  6283.  
  6284. PObject::Comparison MCS_CArq::Compare(const PObject & obj) const
  6285. {
  6286. #ifndef PASN_LEANANDMEAN
  6287.   PAssert(IsDescendant(MCS_CArq::Class()), PInvalidCast);
  6288. #endif
  6289.   const MCS_CArq & other = (const MCS_CArq &)obj;
  6290.  
  6291.   Comparison result;
  6292.  
  6293.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  6294.     return result;
  6295.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  6296.     return result;
  6297.   if ((result = m_userIds.Compare(other.m_userIds)) != EqualTo)
  6298.     return result;
  6299.  
  6300.   return PASN_Sequence::Compare(other);
  6301. }
  6302.  
  6303.  
  6304. PINDEX MCS_CArq::GetDataLength() const
  6305. {
  6306.   PINDEX length = 0;
  6307.   length += m_initiator.GetObjectLength();
  6308.   length += m_channelId.GetObjectLength();
  6309.   length += m_userIds.GetObjectLength();
  6310.   return length;
  6311. }
  6312.  
  6313.  
  6314. BOOL MCS_CArq::Decode(PASN_Stream & strm)
  6315. {
  6316.   if (!PreambleDecode(strm))
  6317.     return FALSE;
  6318.  
  6319.   if (!m_initiator.Decode(strm))
  6320.     return FALSE;
  6321.   if (!m_channelId.Decode(strm))
  6322.     return FALSE;
  6323.   if (!m_userIds.Decode(strm))
  6324.     return FALSE;
  6325.  
  6326.   return UnknownExtensionsDecode(strm);
  6327. }
  6328.  
  6329.  
  6330. void MCS_CArq::Encode(PASN_Stream & strm) const
  6331. {
  6332.   PreambleEncode(strm);
  6333.  
  6334.   m_initiator.Encode(strm);
  6335.   m_channelId.Encode(strm);
  6336.   m_userIds.Encode(strm);
  6337.  
  6338.   UnknownExtensionsEncode(strm);
  6339. }
  6340.  
  6341.  
  6342. PObject * MCS_CArq::Clone() const
  6343. {
  6344. #ifndef PASN_LEANANDMEAN
  6345.   PAssert(IsClass(MCS_CArq::Class()), PInvalidCast);
  6346. #endif
  6347.   return new MCS_CArq(*this);
  6348. }
  6349.  
  6350.  
  6351. //
  6352. // CAin
  6353. //
  6354.  
  6355. MCS_CAin::MCS_CAin(unsigned tag, PASN_Object::TagClass tagClass)
  6356.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6357. {
  6358. }
  6359.  
  6360.  
  6361. #ifndef PASN_NOPRINTON
  6362. void MCS_CAin::PrintOn(ostream & strm) const
  6363. {
  6364.   int indent = strm.precision() + 2;
  6365.   strm << "{\n";
  6366.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  6367.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  6368.   strm << setw(indent+10) << "userIds = " << setprecision(indent) << m_userIds << '\n';
  6369.   strm << setw(indent-1) << "}";
  6370. }
  6371. #endif
  6372.  
  6373.  
  6374. PObject::Comparison MCS_CAin::Compare(const PObject & obj) const
  6375. {
  6376. #ifndef PASN_LEANANDMEAN
  6377.   PAssert(IsDescendant(MCS_CAin::Class()), PInvalidCast);
  6378. #endif
  6379.   const MCS_CAin & other = (const MCS_CAin &)obj;
  6380.  
  6381.   Comparison result;
  6382.  
  6383.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  6384.     return result;
  6385.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  6386.     return result;
  6387.   if ((result = m_userIds.Compare(other.m_userIds)) != EqualTo)
  6388.     return result;
  6389.  
  6390.   return PASN_Sequence::Compare(other);
  6391. }
  6392.  
  6393.  
  6394. PINDEX MCS_CAin::GetDataLength() const
  6395. {
  6396.   PINDEX length = 0;
  6397.   length += m_initiator.GetObjectLength();
  6398.   length += m_channelId.GetObjectLength();
  6399.   length += m_userIds.GetObjectLength();
  6400.   return length;
  6401. }
  6402.  
  6403.  
  6404. BOOL MCS_CAin::Decode(PASN_Stream & strm)
  6405. {
  6406.   if (!PreambleDecode(strm))
  6407.     return FALSE;
  6408.  
  6409.   if (!m_initiator.Decode(strm))
  6410.     return FALSE;
  6411.   if (!m_channelId.Decode(strm))
  6412.     return FALSE;
  6413.   if (!m_userIds.Decode(strm))
  6414.     return FALSE;
  6415.  
  6416.   return UnknownExtensionsDecode(strm);
  6417. }
  6418.  
  6419.  
  6420. void MCS_CAin::Encode(PASN_Stream & strm) const
  6421. {
  6422.   PreambleEncode(strm);
  6423.  
  6424.   m_initiator.Encode(strm);
  6425.   m_channelId.Encode(strm);
  6426.   m_userIds.Encode(strm);
  6427.  
  6428.   UnknownExtensionsEncode(strm);
  6429. }
  6430.  
  6431.  
  6432. PObject * MCS_CAin::Clone() const
  6433. {
  6434. #ifndef PASN_LEANANDMEAN
  6435.   PAssert(IsClass(MCS_CAin::Class()), PInvalidCast);
  6436. #endif
  6437.   return new MCS_CAin(*this);
  6438. }
  6439.  
  6440.  
  6441. //
  6442. // CErq
  6443. //
  6444.  
  6445. MCS_CErq::MCS_CErq(unsigned tag, PASN_Object::TagClass tagClass)
  6446.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6447. {
  6448. }
  6449.  
  6450.  
  6451. #ifndef PASN_NOPRINTON
  6452. void MCS_CErq::PrintOn(ostream & strm) const
  6453. {
  6454.   int indent = strm.precision() + 2;
  6455.   strm << "{\n";
  6456.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  6457.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  6458.   strm << setw(indent+10) << "userIds = " << setprecision(indent) << m_userIds << '\n';
  6459.   strm << setw(indent-1) << "}";
  6460. }
  6461. #endif
  6462.  
  6463.  
  6464. PObject::Comparison MCS_CErq::Compare(const PObject & obj) const
  6465. {
  6466. #ifndef PASN_LEANANDMEAN
  6467.   PAssert(IsDescendant(MCS_CErq::Class()), PInvalidCast);
  6468. #endif
  6469.   const MCS_CErq & other = (const MCS_CErq &)obj;
  6470.  
  6471.   Comparison result;
  6472.  
  6473.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  6474.     return result;
  6475.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  6476.     return result;
  6477.   if ((result = m_userIds.Compare(other.m_userIds)) != EqualTo)
  6478.     return result;
  6479.  
  6480.   return PASN_Sequence::Compare(other);
  6481. }
  6482.  
  6483.  
  6484. PINDEX MCS_CErq::GetDataLength() const
  6485. {
  6486.   PINDEX length = 0;
  6487.   length += m_initiator.GetObjectLength();
  6488.   length += m_channelId.GetObjectLength();
  6489.   length += m_userIds.GetObjectLength();
  6490.   return length;
  6491. }
  6492.  
  6493.  
  6494. BOOL MCS_CErq::Decode(PASN_Stream & strm)
  6495. {
  6496.   if (!PreambleDecode(strm))
  6497.     return FALSE;
  6498.  
  6499.   if (!m_initiator.Decode(strm))
  6500.     return FALSE;
  6501.   if (!m_channelId.Decode(strm))
  6502.     return FALSE;
  6503.   if (!m_userIds.Decode(strm))
  6504.     return FALSE;
  6505.  
  6506.   return UnknownExtensionsDecode(strm);
  6507. }
  6508.  
  6509.  
  6510. void MCS_CErq::Encode(PASN_Stream & strm) const
  6511. {
  6512.   PreambleEncode(strm);
  6513.  
  6514.   m_initiator.Encode(strm);
  6515.   m_channelId.Encode(strm);
  6516.   m_userIds.Encode(strm);
  6517.  
  6518.   UnknownExtensionsEncode(strm);
  6519. }
  6520.  
  6521.  
  6522. PObject * MCS_CErq::Clone() const
  6523. {
  6524. #ifndef PASN_LEANANDMEAN
  6525.   PAssert(IsClass(MCS_CErq::Class()), PInvalidCast);
  6526. #endif
  6527.   return new MCS_CErq(*this);
  6528. }
  6529.  
  6530.  
  6531. //
  6532. // CEin
  6533. //
  6534.  
  6535. MCS_CEin::MCS_CEin(unsigned tag, PASN_Object::TagClass tagClass)
  6536.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6537. {
  6538. }
  6539.  
  6540.  
  6541. #ifndef PASN_NOPRINTON
  6542. void MCS_CEin::PrintOn(ostream & strm) const
  6543. {
  6544.   int indent = strm.precision() + 2;
  6545.   strm << "{\n";
  6546.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  6547.   strm << setw(indent+10) << "userIds = " << setprecision(indent) << m_userIds << '\n';
  6548.   strm << setw(indent-1) << "}";
  6549. }
  6550. #endif
  6551.  
  6552.  
  6553. PObject::Comparison MCS_CEin::Compare(const PObject & obj) const
  6554. {
  6555. #ifndef PASN_LEANANDMEAN
  6556.   PAssert(IsDescendant(MCS_CEin::Class()), PInvalidCast);
  6557. #endif
  6558.   const MCS_CEin & other = (const MCS_CEin &)obj;
  6559.  
  6560.   Comparison result;
  6561.  
  6562.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  6563.     return result;
  6564.   if ((result = m_userIds.Compare(other.m_userIds)) != EqualTo)
  6565.     return result;
  6566.  
  6567.   return PASN_Sequence::Compare(other);
  6568. }
  6569.  
  6570.  
  6571. PINDEX MCS_CEin::GetDataLength() const
  6572. {
  6573.   PINDEX length = 0;
  6574.   length += m_channelId.GetObjectLength();
  6575.   length += m_userIds.GetObjectLength();
  6576.   return length;
  6577. }
  6578.  
  6579.  
  6580. BOOL MCS_CEin::Decode(PASN_Stream & strm)
  6581. {
  6582.   if (!PreambleDecode(strm))
  6583.     return FALSE;
  6584.  
  6585.   if (!m_channelId.Decode(strm))
  6586.     return FALSE;
  6587.   if (!m_userIds.Decode(strm))
  6588.     return FALSE;
  6589.  
  6590.   return UnknownExtensionsDecode(strm);
  6591. }
  6592.  
  6593.  
  6594. void MCS_CEin::Encode(PASN_Stream & strm) const
  6595. {
  6596.   PreambleEncode(strm);
  6597.  
  6598.   m_channelId.Encode(strm);
  6599.   m_userIds.Encode(strm);
  6600.  
  6601.   UnknownExtensionsEncode(strm);
  6602. }
  6603.  
  6604.  
  6605. PObject * MCS_CEin::Clone() const
  6606. {
  6607. #ifndef PASN_LEANANDMEAN
  6608.   PAssert(IsClass(MCS_CEin::Class()), PInvalidCast);
  6609. #endif
  6610.   return new MCS_CEin(*this);
  6611. }
  6612.  
  6613.  
  6614. //
  6615. // TGcf
  6616. //
  6617.  
  6618. MCS_TGcf::MCS_TGcf(unsigned tag, PASN_Object::TagClass tagClass)
  6619.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6620. {
  6621. }
  6622.  
  6623.  
  6624. #ifndef PASN_NOPRINTON
  6625. void MCS_TGcf::PrintOn(ostream & strm) const
  6626. {
  6627.   int indent = strm.precision() + 2;
  6628.   strm << "{\n";
  6629.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  6630.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  6631.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  6632.   strm << setw(indent+14) << "tokenStatus = " << setprecision(indent) << m_tokenStatus << '\n';
  6633.   strm << setw(indent-1) << "}";
  6634. }
  6635. #endif
  6636.  
  6637.  
  6638. PObject::Comparison MCS_TGcf::Compare(const PObject & obj) const
  6639. {
  6640. #ifndef PASN_LEANANDMEAN
  6641.   PAssert(IsDescendant(MCS_TGcf::Class()), PInvalidCast);
  6642. #endif
  6643.   const MCS_TGcf & other = (const MCS_TGcf &)obj;
  6644.  
  6645.   Comparison result;
  6646.  
  6647.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  6648.     return result;
  6649.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  6650.     return result;
  6651.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  6652.     return result;
  6653.   if ((result = m_tokenStatus.Compare(other.m_tokenStatus)) != EqualTo)
  6654.     return result;
  6655.  
  6656.   return PASN_Sequence::Compare(other);
  6657. }
  6658.  
  6659.  
  6660. PINDEX MCS_TGcf::GetDataLength() const
  6661. {
  6662.   PINDEX length = 0;
  6663.   length += m_result.GetObjectLength();
  6664.   length += m_initiator.GetObjectLength();
  6665.   length += m_tokenId.GetObjectLength();
  6666.   length += m_tokenStatus.GetObjectLength();
  6667.   return length;
  6668. }
  6669.  
  6670.  
  6671. BOOL MCS_TGcf::Decode(PASN_Stream & strm)
  6672. {
  6673.   if (!PreambleDecode(strm))
  6674.     return FALSE;
  6675.  
  6676.   if (!m_result.Decode(strm))
  6677.     return FALSE;
  6678.   if (!m_initiator.Decode(strm))
  6679.     return FALSE;
  6680.   if (!m_tokenId.Decode(strm))
  6681.     return FALSE;
  6682.   if (!m_tokenStatus.Decode(strm))
  6683.     return FALSE;
  6684.  
  6685.   return UnknownExtensionsDecode(strm);
  6686. }
  6687.  
  6688.  
  6689. void MCS_TGcf::Encode(PASN_Stream & strm) const
  6690. {
  6691.   PreambleEncode(strm);
  6692.  
  6693.   m_result.Encode(strm);
  6694.   m_initiator.Encode(strm);
  6695.   m_tokenId.Encode(strm);
  6696.   m_tokenStatus.Encode(strm);
  6697.  
  6698.   UnknownExtensionsEncode(strm);
  6699. }
  6700.  
  6701.  
  6702. PObject * MCS_TGcf::Clone() const
  6703. {
  6704. #ifndef PASN_LEANANDMEAN
  6705.   PAssert(IsClass(MCS_TGcf::Class()), PInvalidCast);
  6706. #endif
  6707.   return new MCS_TGcf(*this);
  6708. }
  6709.  
  6710.  
  6711. //
  6712. // TIcf
  6713. //
  6714.  
  6715. MCS_TIcf::MCS_TIcf(unsigned tag, PASN_Object::TagClass tagClass)
  6716.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6717. {
  6718. }
  6719.  
  6720.  
  6721. #ifndef PASN_NOPRINTON
  6722. void MCS_TIcf::PrintOn(ostream & strm) const
  6723. {
  6724.   int indent = strm.precision() + 2;
  6725.   strm << "{\n";
  6726.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  6727.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  6728.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  6729.   strm << setw(indent+14) << "tokenStatus = " << setprecision(indent) << m_tokenStatus << '\n';
  6730.   strm << setw(indent-1) << "}";
  6731. }
  6732. #endif
  6733.  
  6734.  
  6735. PObject::Comparison MCS_TIcf::Compare(const PObject & obj) const
  6736. {
  6737. #ifndef PASN_LEANANDMEAN
  6738.   PAssert(IsDescendant(MCS_TIcf::Class()), PInvalidCast);
  6739. #endif
  6740.   const MCS_TIcf & other = (const MCS_TIcf &)obj;
  6741.  
  6742.   Comparison result;
  6743.  
  6744.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  6745.     return result;
  6746.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  6747.     return result;
  6748.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  6749.     return result;
  6750.   if ((result = m_tokenStatus.Compare(other.m_tokenStatus)) != EqualTo)
  6751.     return result;
  6752.  
  6753.   return PASN_Sequence::Compare(other);
  6754. }
  6755.  
  6756.  
  6757. PINDEX MCS_TIcf::GetDataLength() const
  6758. {
  6759.   PINDEX length = 0;
  6760.   length += m_result.GetObjectLength();
  6761.   length += m_initiator.GetObjectLength();
  6762.   length += m_tokenId.GetObjectLength();
  6763.   length += m_tokenStatus.GetObjectLength();
  6764.   return length;
  6765. }
  6766.  
  6767.  
  6768. BOOL MCS_TIcf::Decode(PASN_Stream & strm)
  6769. {
  6770.   if (!PreambleDecode(strm))
  6771.     return FALSE;
  6772.  
  6773.   if (!m_result.Decode(strm))
  6774.     return FALSE;
  6775.   if (!m_initiator.Decode(strm))
  6776.     return FALSE;
  6777.   if (!m_tokenId.Decode(strm))
  6778.     return FALSE;
  6779.   if (!m_tokenStatus.Decode(strm))
  6780.     return FALSE;
  6781.  
  6782.   return UnknownExtensionsDecode(strm);
  6783. }
  6784.  
  6785.  
  6786. void MCS_TIcf::Encode(PASN_Stream & strm) const
  6787. {
  6788.   PreambleEncode(strm);
  6789.  
  6790.   m_result.Encode(strm);
  6791.   m_initiator.Encode(strm);
  6792.   m_tokenId.Encode(strm);
  6793.   m_tokenStatus.Encode(strm);
  6794.  
  6795.   UnknownExtensionsEncode(strm);
  6796. }
  6797.  
  6798.  
  6799. PObject * MCS_TIcf::Clone() const
  6800. {
  6801. #ifndef PASN_LEANANDMEAN
  6802.   PAssert(IsClass(MCS_TIcf::Class()), PInvalidCast);
  6803. #endif
  6804.   return new MCS_TIcf(*this);
  6805. }
  6806.  
  6807.  
  6808. //
  6809. // TVrs
  6810. //
  6811.  
  6812. MCS_TVrs::MCS_TVrs(unsigned tag, PASN_Object::TagClass tagClass)
  6813.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6814. {
  6815. }
  6816.  
  6817.  
  6818. #ifndef PASN_NOPRINTON
  6819. void MCS_TVrs::PrintOn(ostream & strm) const
  6820. {
  6821.   int indent = strm.precision() + 2;
  6822.   strm << "{\n";
  6823.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  6824.   strm << setw(indent+12) << "recipient = " << setprecision(indent) << m_recipient << '\n';
  6825.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  6826.   strm << setw(indent-1) << "}";
  6827. }
  6828. #endif
  6829.  
  6830.  
  6831. PObject::Comparison MCS_TVrs::Compare(const PObject & obj) const
  6832. {
  6833. #ifndef PASN_LEANANDMEAN
  6834.   PAssert(IsDescendant(MCS_TVrs::Class()), PInvalidCast);
  6835. #endif
  6836.   const MCS_TVrs & other = (const MCS_TVrs &)obj;
  6837.  
  6838.   Comparison result;
  6839.  
  6840.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  6841.     return result;
  6842.   if ((result = m_recipient.Compare(other.m_recipient)) != EqualTo)
  6843.     return result;
  6844.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  6845.     return result;
  6846.  
  6847.   return PASN_Sequence::Compare(other);
  6848. }
  6849.  
  6850.  
  6851. PINDEX MCS_TVrs::GetDataLength() const
  6852. {
  6853.   PINDEX length = 0;
  6854.   length += m_result.GetObjectLength();
  6855.   length += m_recipient.GetObjectLength();
  6856.   length += m_tokenId.GetObjectLength();
  6857.   return length;
  6858. }
  6859.  
  6860.  
  6861. BOOL MCS_TVrs::Decode(PASN_Stream & strm)
  6862. {
  6863.   if (!PreambleDecode(strm))
  6864.     return FALSE;
  6865.  
  6866.   if (!m_result.Decode(strm))
  6867.     return FALSE;
  6868.   if (!m_recipient.Decode(strm))
  6869.     return FALSE;
  6870.   if (!m_tokenId.Decode(strm))
  6871.     return FALSE;
  6872.  
  6873.   return UnknownExtensionsDecode(strm);
  6874. }
  6875.  
  6876.  
  6877. void MCS_TVrs::Encode(PASN_Stream & strm) const
  6878. {
  6879.   PreambleEncode(strm);
  6880.  
  6881.   m_result.Encode(strm);
  6882.   m_recipient.Encode(strm);
  6883.   m_tokenId.Encode(strm);
  6884.  
  6885.   UnknownExtensionsEncode(strm);
  6886. }
  6887.  
  6888.  
  6889. PObject * MCS_TVrs::Clone() const
  6890. {
  6891. #ifndef PASN_LEANANDMEAN
  6892.   PAssert(IsClass(MCS_TVrs::Class()), PInvalidCast);
  6893. #endif
  6894.   return new MCS_TVrs(*this);
  6895. }
  6896.  
  6897.  
  6898. //
  6899. // TVcf
  6900. //
  6901.  
  6902. MCS_TVcf::MCS_TVcf(unsigned tag, PASN_Object::TagClass tagClass)
  6903.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6904. {
  6905. }
  6906.  
  6907.  
  6908. #ifndef PASN_NOPRINTON
  6909. void MCS_TVcf::PrintOn(ostream & strm) const
  6910. {
  6911.   int indent = strm.precision() + 2;
  6912.   strm << "{\n";
  6913.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  6914.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  6915.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  6916.   strm << setw(indent+14) << "tokenStatus = " << setprecision(indent) << m_tokenStatus << '\n';
  6917.   strm << setw(indent-1) << "}";
  6918. }
  6919. #endif
  6920.  
  6921.  
  6922. PObject::Comparison MCS_TVcf::Compare(const PObject & obj) const
  6923. {
  6924. #ifndef PASN_LEANANDMEAN
  6925.   PAssert(IsDescendant(MCS_TVcf::Class()), PInvalidCast);
  6926. #endif
  6927.   const MCS_TVcf & other = (const MCS_TVcf &)obj;
  6928.  
  6929.   Comparison result;
  6930.  
  6931.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  6932.     return result;
  6933.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  6934.     return result;
  6935.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  6936.     return result;
  6937.   if ((result = m_tokenStatus.Compare(other.m_tokenStatus)) != EqualTo)
  6938.     return result;
  6939.  
  6940.   return PASN_Sequence::Compare(other);
  6941. }
  6942.  
  6943.  
  6944. PINDEX MCS_TVcf::GetDataLength() const
  6945. {
  6946.   PINDEX length = 0;
  6947.   length += m_result.GetObjectLength();
  6948.   length += m_initiator.GetObjectLength();
  6949.   length += m_tokenId.GetObjectLength();
  6950.   length += m_tokenStatus.GetObjectLength();
  6951.   return length;
  6952. }
  6953.  
  6954.  
  6955. BOOL MCS_TVcf::Decode(PASN_Stream & strm)
  6956. {
  6957.   if (!PreambleDecode(strm))
  6958.     return FALSE;
  6959.  
  6960.   if (!m_result.Decode(strm))
  6961.     return FALSE;
  6962.   if (!m_initiator.Decode(strm))
  6963.     return FALSE;
  6964.   if (!m_tokenId.Decode(strm))
  6965.     return FALSE;
  6966.   if (!m_tokenStatus.Decode(strm))
  6967.     return FALSE;
  6968.  
  6969.   return UnknownExtensionsDecode(strm);
  6970. }
  6971.  
  6972.  
  6973. void MCS_TVcf::Encode(PASN_Stream & strm) const
  6974. {
  6975.   PreambleEncode(strm);
  6976.  
  6977.   m_result.Encode(strm);
  6978.   m_initiator.Encode(strm);
  6979.   m_tokenId.Encode(strm);
  6980.   m_tokenStatus.Encode(strm);
  6981.  
  6982.   UnknownExtensionsEncode(strm);
  6983. }
  6984.  
  6985.  
  6986. PObject * MCS_TVcf::Clone() const
  6987. {
  6988. #ifndef PASN_LEANANDMEAN
  6989.   PAssert(IsClass(MCS_TVcf::Class()), PInvalidCast);
  6990. #endif
  6991.   return new MCS_TVcf(*this);
  6992. }
  6993.  
  6994.  
  6995. //
  6996. // TRcf
  6997. //
  6998.  
  6999. MCS_TRcf::MCS_TRcf(unsigned tag, PASN_Object::TagClass tagClass)
  7000.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  7001. {
  7002. }
  7003.  
  7004.  
  7005. #ifndef PASN_NOPRINTON
  7006. void MCS_TRcf::PrintOn(ostream & strm) const
  7007. {
  7008.   int indent = strm.precision() + 2;
  7009.   strm << "{\n";
  7010.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  7011.   strm << setw(indent+12) << "initiator = " << setprecision(indent) << m_initiator << '\n';
  7012.   strm << setw(indent+10) << "tokenId = " << setprecision(indent) << m_tokenId << '\n';
  7013.   strm << setw(indent+14) << "tokenStatus = " << setprecision(indent) << m_tokenStatus << '\n';
  7014.   strm << setw(indent-1) << "}";
  7015. }
  7016. #endif
  7017.  
  7018.  
  7019. PObject::Comparison MCS_TRcf::Compare(const PObject & obj) const
  7020. {
  7021. #ifndef PASN_LEANANDMEAN
  7022.   PAssert(IsDescendant(MCS_TRcf::Class()), PInvalidCast);
  7023. #endif
  7024.   const MCS_TRcf & other = (const MCS_TRcf &)obj;
  7025.  
  7026.   Comparison result;
  7027.  
  7028.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  7029.     return result;
  7030.   if ((result = m_initiator.Compare(other.m_initiator)) != EqualTo)
  7031.     return result;
  7032.   if ((result = m_tokenId.Compare(other.m_tokenId)) != EqualTo)
  7033.     return result;
  7034.   if ((result = m_tokenStatus.Compare(other.m_tokenStatus)) != EqualTo)
  7035.     return result;
  7036.  
  7037.   return PASN_Sequence::Compare(other);
  7038. }
  7039.  
  7040.  
  7041. PINDEX MCS_TRcf::GetDataLength() const
  7042. {
  7043.   PINDEX length = 0;
  7044.   length += m_result.GetObjectLength();
  7045.   length += m_initiator.GetObjectLength();
  7046.   length += m_tokenId.GetObjectLength();
  7047.   length += m_tokenStatus.GetObjectLength();
  7048.   return length;
  7049. }
  7050.  
  7051.  
  7052. BOOL MCS_TRcf::Decode(PASN_Stream & strm)
  7053. {
  7054.   if (!PreambleDecode(strm))
  7055.     return FALSE;
  7056.  
  7057.   if (!m_result.Decode(strm))
  7058.     return FALSE;
  7059.   if (!m_initiator.Decode(strm))
  7060.     return FALSE;
  7061.   if (!m_tokenId.Decode(strm))
  7062.     return FALSE;
  7063.   if (!m_tokenStatus.Decode(strm))
  7064.     return FALSE;
  7065.  
  7066.   return UnknownExtensionsDecode(strm);
  7067. }
  7068.  
  7069.  
  7070. void MCS_TRcf::Encode(PASN_Stream & strm) const
  7071. {
  7072.   PreambleEncode(strm);
  7073.  
  7074.   m_result.Encode(strm);
  7075.   m_initiator.Encode(strm);
  7076.   m_tokenId.Encode(strm);
  7077.   m_tokenStatus.Encode(strm);
  7078.  
  7079.   UnknownExtensionsEncode(strm);
  7080. }
  7081.  
  7082.  
  7083. PObject * MCS_TRcf::Clone() const
  7084. {
  7085. #ifndef PASN_LEANANDMEAN
  7086.   PAssert(IsClass(MCS_TRcf::Class()), PInvalidCast);
  7087. #endif
  7088.   return new MCS_TRcf(*this);
  7089. }
  7090.  
  7091.  
  7092. //
  7093. // ChannelAttributes_private
  7094. //
  7095.  
  7096. MCS_ChannelAttributes_private::MCS_ChannelAttributes_private(unsigned tag, PASN_Object::TagClass tagClass)
  7097.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  7098. {
  7099. }
  7100.  
  7101.  
  7102. #ifndef PASN_NOPRINTON
  7103. void MCS_ChannelAttributes_private::PrintOn(ostream & strm) const
  7104. {
  7105.   int indent = strm.precision() + 2;
  7106.   strm << "{\n";
  7107.   strm << setw(indent+9) << "joined = " << setprecision(indent) << m_joined << '\n';
  7108.   strm << setw(indent+12) << "channelId = " << setprecision(indent) << m_channelId << '\n';
  7109.   strm << setw(indent+10) << "manager = " << setprecision(indent) << m_manager << '\n';
  7110.   strm << setw(indent+11) << "admitted = " << setprecision(indent) << m_admitted << '\n';
  7111.   strm << setw(indent-1) << "}";
  7112. }
  7113. #endif
  7114.  
  7115.  
  7116. PObject::Comparison MCS_ChannelAttributes_private::Compare(const PObject & obj) const
  7117. {
  7118. #ifndef PASN_LEANANDMEAN
  7119.   PAssert(IsDescendant(MCS_ChannelAttributes_private::Class()), PInvalidCast);
  7120. #endif
  7121.   const MCS_ChannelAttributes_private & other = (const MCS_ChannelAttributes_private &)obj;
  7122.  
  7123.   Comparison result;
  7124.  
  7125.   if ((result = m_joined.Compare(other.m_joined)) != EqualTo)
  7126.     return result;
  7127.   if ((result = m_channelId.Compare(other.m_channelId)) != EqualTo)
  7128.     return result;
  7129.   if ((result = m_manager.Compare(other.m_manager)) != EqualTo)
  7130.     return result;
  7131.   if ((result = m_admitted.Compare(other.m_admitted)) != EqualTo)
  7132.     return result;
  7133.  
  7134.   return PASN_Sequence::Compare(other);
  7135. }
  7136.  
  7137.  
  7138. PINDEX MCS_ChannelAttributes_private::GetDataLength() const
  7139. {
  7140.   PINDEX length = 0;
  7141.   length += m_joined.GetObjectLength();
  7142.   length += m_channelId.GetObjectLength();
  7143.   length += m_manager.GetObjectLength();
  7144.   length += m_admitted.GetObjectLength();
  7145.   return length;
  7146. }
  7147.  
  7148.  
  7149. BOOL MCS_ChannelAttributes_private::Decode(PASN_Stream & strm)
  7150. {
  7151.   if (!PreambleDecode(strm))
  7152.     return FALSE;
  7153.  
  7154.   if (!m_joined.Decode(strm))
  7155.     return FALSE;
  7156.   if (!m_channelId.Decode(strm))
  7157.     return FALSE;
  7158.   if (!m_manager.Decode(strm))
  7159.     return FALSE;
  7160.   if (!m_admitted.Decode(strm))
  7161.     return FALSE;
  7162.  
  7163.   return UnknownExtensionsDecode(strm);
  7164. }
  7165.  
  7166.  
  7167. void MCS_ChannelAttributes_private::Encode(PASN_Stream & strm) const
  7168. {
  7169.   PreambleEncode(strm);
  7170.  
  7171.   m_joined.Encode(strm);
  7172.   m_channelId.Encode(strm);
  7173.   m_manager.Encode(strm);
  7174.   m_admitted.Encode(strm);
  7175.  
  7176.   UnknownExtensionsEncode(strm);
  7177. }
  7178.  
  7179.  
  7180. PObject * MCS_ChannelAttributes_private::Clone() const
  7181. {
  7182. #ifndef PASN_LEANANDMEAN
  7183.   PAssert(IsClass(MCS_ChannelAttributes_private::Class()), PInvalidCast);
  7184. #endif
  7185.   return new MCS_ChannelAttributes_private(*this);
  7186. }
  7187.  
  7188.  
  7189. #endif // if ! H323_DISABLE_MCS
  7190.  
  7191.  
  7192. // End of mcspdu.cxx
  7193.