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 / gccpdu.cxx < prev    next >
C/C++ Source or Header  |  2004-06-22  |  337KB  |  12,438 lines
  1. //
  2. // gccpdu.cxx
  3. //
  4. // Code automatically generated by asnparse.
  5. //
  6.  
  7. #ifdef __GNUC__
  8. #pragma implementation "gccpdu.h"
  9. #endif
  10.  
  11. #include <ptlib.h>
  12. #include "gccpdu.h"
  13.  
  14. #define new PNEW
  15.  
  16.  
  17. #if ! H323_DISABLE_GCC
  18.  
  19. //
  20. // ChannelID
  21. //
  22.  
  23. GCC_ChannelID::GCC_ChannelID(unsigned tag, PASN_Object::TagClass tagClass)
  24.   : PASN_Integer(tag, tagClass)
  25. {
  26.   SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
  27. }
  28.  
  29.  
  30. GCC_ChannelID & GCC_ChannelID::operator=(int v)
  31. {
  32.   SetValue(v);
  33.   return *this;
  34. }
  35.  
  36.  
  37. GCC_ChannelID & GCC_ChannelID::operator=(unsigned v)
  38. {
  39.   SetValue(v);
  40.   return *this;
  41. }
  42.  
  43.  
  44. PObject * GCC_ChannelID::Clone() const
  45. {
  46. #ifndef PASN_LEANANDMEAN
  47.   PAssert(IsClass(GCC_ChannelID::Class()), PInvalidCast);
  48. #endif
  49.   return new GCC_ChannelID(*this);
  50. }
  51.  
  52.  
  53. //
  54. // StaticChannelID
  55. //
  56.  
  57. GCC_StaticChannelID::GCC_StaticChannelID(unsigned tag, PASN_Object::TagClass tagClass)
  58.   : PASN_Integer(tag, tagClass)
  59. {
  60.   SetConstraints(PASN_Object::FixedConstraint, 1, 1000);
  61. }
  62.  
  63.  
  64. GCC_StaticChannelID & GCC_StaticChannelID::operator=(int v)
  65. {
  66.   SetValue(v);
  67.   return *this;
  68. }
  69.  
  70.  
  71. GCC_StaticChannelID & GCC_StaticChannelID::operator=(unsigned v)
  72. {
  73.   SetValue(v);
  74.   return *this;
  75. }
  76.  
  77.  
  78. PObject * GCC_StaticChannelID::Clone() const
  79. {
  80. #ifndef PASN_LEANANDMEAN
  81.   PAssert(IsClass(GCC_StaticChannelID::Class()), PInvalidCast);
  82. #endif
  83.   return new GCC_StaticChannelID(*this);
  84. }
  85.  
  86.  
  87. //
  88. // DynamicChannelID
  89. //
  90.  
  91. GCC_DynamicChannelID::GCC_DynamicChannelID(unsigned tag, PASN_Object::TagClass tagClass)
  92.   : PASN_Integer(tag, tagClass)
  93. {
  94.   SetConstraints(PASN_Object::FixedConstraint, 1001, 65535);
  95. }
  96.  
  97.  
  98. GCC_DynamicChannelID & GCC_DynamicChannelID::operator=(int v)
  99. {
  100.   SetValue(v);
  101.   return *this;
  102. }
  103.  
  104.  
  105. GCC_DynamicChannelID & GCC_DynamicChannelID::operator=(unsigned v)
  106. {
  107.   SetValue(v);
  108.   return *this;
  109. }
  110.  
  111.  
  112. PObject * GCC_DynamicChannelID::Clone() const
  113. {
  114. #ifndef PASN_LEANANDMEAN
  115.   PAssert(IsClass(GCC_DynamicChannelID::Class()), PInvalidCast);
  116. #endif
  117.   return new GCC_DynamicChannelID(*this);
  118. }
  119.  
  120.  
  121. //
  122. // UserID
  123. //
  124.  
  125. GCC_UserID::GCC_UserID(unsigned tag, PASN_Object::TagClass tagClass)
  126.   : GCC_DynamicChannelID(tag, tagClass)
  127. {
  128. }
  129.  
  130.  
  131. GCC_UserID & GCC_UserID::operator=(int v)
  132. {
  133.   SetValue(v);
  134.   return *this;
  135. }
  136.  
  137.  
  138. GCC_UserID & GCC_UserID::operator=(unsigned v)
  139. {
  140.   SetValue(v);
  141.   return *this;
  142. }
  143.  
  144.  
  145. PObject * GCC_UserID::Clone() const
  146. {
  147. #ifndef PASN_LEANANDMEAN
  148.   PAssert(IsClass(GCC_UserID::Class()), PInvalidCast);
  149. #endif
  150.   return new GCC_UserID(*this);
  151. }
  152.  
  153.  
  154. //
  155. // TokenID
  156. //
  157.  
  158. GCC_TokenID::GCC_TokenID(unsigned tag, PASN_Object::TagClass tagClass)
  159.   : PASN_Integer(tag, tagClass)
  160. {
  161.   SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
  162. }
  163.  
  164.  
  165. GCC_TokenID & GCC_TokenID::operator=(int v)
  166. {
  167.   SetValue(v);
  168.   return *this;
  169. }
  170.  
  171.  
  172. GCC_TokenID & GCC_TokenID::operator=(unsigned v)
  173. {
  174.   SetValue(v);
  175.   return *this;
  176. }
  177.  
  178.  
  179. PObject * GCC_TokenID::Clone() const
  180. {
  181. #ifndef PASN_LEANANDMEAN
  182.   PAssert(IsClass(GCC_TokenID::Class()), PInvalidCast);
  183. #endif
  184.   return new GCC_TokenID(*this);
  185. }
  186.  
  187.  
  188. //
  189. // StaticTokenID
  190. //
  191.  
  192. GCC_StaticTokenID::GCC_StaticTokenID(unsigned tag, PASN_Object::TagClass tagClass)
  193.   : PASN_Integer(tag, tagClass)
  194. {
  195.   SetConstraints(PASN_Object::FixedConstraint, 1, 16383);
  196. }
  197.  
  198.  
  199. GCC_StaticTokenID & GCC_StaticTokenID::operator=(int v)
  200. {
  201.   SetValue(v);
  202.   return *this;
  203. }
  204.  
  205.  
  206. GCC_StaticTokenID & GCC_StaticTokenID::operator=(unsigned v)
  207. {
  208.   SetValue(v);
  209.   return *this;
  210. }
  211.  
  212.  
  213. PObject * GCC_StaticTokenID::Clone() const
  214. {
  215. #ifndef PASN_LEANANDMEAN
  216.   PAssert(IsClass(GCC_StaticTokenID::Class()), PInvalidCast);
  217. #endif
  218.   return new GCC_StaticTokenID(*this);
  219. }
  220.  
  221.  
  222. //
  223. // DynamicTokenID
  224. //
  225.  
  226. GCC_DynamicTokenID::GCC_DynamicTokenID(unsigned tag, PASN_Object::TagClass tagClass)
  227.   : PASN_Integer(tag, tagClass)
  228. {
  229.   SetConstraints(PASN_Object::FixedConstraint, 16384, 65535);
  230. }
  231.  
  232.  
  233. GCC_DynamicTokenID & GCC_DynamicTokenID::operator=(int v)
  234. {
  235.   SetValue(v);
  236.   return *this;
  237. }
  238.  
  239.  
  240. GCC_DynamicTokenID & GCC_DynamicTokenID::operator=(unsigned v)
  241. {
  242.   SetValue(v);
  243.   return *this;
  244. }
  245.  
  246.  
  247. PObject * GCC_DynamicTokenID::Clone() const
  248. {
  249. #ifndef PASN_LEANANDMEAN
  250.   PAssert(IsClass(GCC_DynamicTokenID::Class()), PInvalidCast);
  251. #endif
  252.   return new GCC_DynamicTokenID(*this);
  253. }
  254.  
  255.  
  256. //
  257. // Time
  258. //
  259.  
  260. GCC_Time::GCC_Time(unsigned tag, PASN_Object::TagClass tagClass)
  261.   : PASN_Integer(tag, tagClass)
  262. {
  263.   SetConstraints(PASN_Object::FixedConstraint, -2147483647, 2147483647);
  264. }
  265.  
  266.  
  267. GCC_Time & GCC_Time::operator=(int v)
  268. {
  269.   SetValue(v);
  270.   return *this;
  271. }
  272.  
  273.  
  274. GCC_Time & GCC_Time::operator=(unsigned v)
  275. {
  276.   SetValue(v);
  277.   return *this;
  278. }
  279.  
  280.  
  281. PObject * GCC_Time::Clone() const
  282. {
  283. #ifndef PASN_LEANANDMEAN
  284.   PAssert(IsClass(GCC_Time::Class()), PInvalidCast);
  285. #endif
  286.   return new GCC_Time(*this);
  287. }
  288.  
  289.  
  290. //
  291. // Handle
  292. //
  293.  
  294. GCC_Handle::GCC_Handle(unsigned tag, PASN_Object::TagClass tagClass)
  295.   : PASN_Integer(tag, tagClass)
  296. {
  297.   SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
  298. }
  299.  
  300.  
  301. GCC_Handle & GCC_Handle::operator=(int v)
  302. {
  303.   SetValue(v);
  304.   return *this;
  305. }
  306.  
  307.  
  308. GCC_Handle & GCC_Handle::operator=(unsigned v)
  309. {
  310.   SetValue(v);
  311.   return *this;
  312. }
  313.  
  314.  
  315. PObject * GCC_Handle::Clone() const
  316. {
  317. #ifndef PASN_LEANANDMEAN
  318.   PAssert(IsClass(GCC_Handle::Class()), PInvalidCast);
  319. #endif
  320.   return new GCC_Handle(*this);
  321. }
  322.  
  323.  
  324. //
  325. // H221NonStandardIdentifier
  326. //
  327.  
  328. GCC_H221NonStandardIdentifier::GCC_H221NonStandardIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
  329.   : PASN_OctetString(tag, tagClass)
  330. {
  331.   SetConstraints(PASN_Object::FixedConstraint, 4, 255);
  332. }
  333.  
  334.  
  335. GCC_H221NonStandardIdentifier::GCC_H221NonStandardIdentifier(const char * v)
  336. {
  337.   SetValue(v);
  338. }
  339.  
  340.  
  341. GCC_H221NonStandardIdentifier::GCC_H221NonStandardIdentifier(const PString & v)
  342. {
  343.   SetValue(v);
  344. }
  345.  
  346.  
  347. GCC_H221NonStandardIdentifier::GCC_H221NonStandardIdentifier(const PBYTEArray & v)
  348. {
  349.   SetValue(v);
  350. }
  351.  
  352.  
  353. GCC_H221NonStandardIdentifier & GCC_H221NonStandardIdentifier::operator=(const char * v)
  354. {
  355.   SetValue(v);
  356.   return *this;
  357. }
  358.  
  359.  
  360. GCC_H221NonStandardIdentifier & GCC_H221NonStandardIdentifier::operator=(const PString & v)
  361. {
  362.   SetValue(v);
  363.   return *this;
  364. }
  365.  
  366.  
  367. GCC_H221NonStandardIdentifier & GCC_H221NonStandardIdentifier::operator=(const PBYTEArray & v)
  368. {
  369.   SetValue(v);
  370.   return *this;
  371. }
  372.  
  373.  
  374. PObject * GCC_H221NonStandardIdentifier::Clone() const
  375. {
  376. #ifndef PASN_LEANANDMEAN
  377.   PAssert(IsClass(GCC_H221NonStandardIdentifier::Class()), PInvalidCast);
  378. #endif
  379.   return new GCC_H221NonStandardIdentifier(*this);
  380. }
  381.  
  382.  
  383. //
  384. // Key
  385. //
  386.  
  387. GCC_Key::GCC_Key(unsigned tag, PASN_Object::TagClass tagClass)
  388.   : PASN_Choice(tag, tagClass, 2, FALSE
  389. #ifndef PASN_NOPRINTON
  390.       , "object "
  391.         "h221NonStandard "
  392. #endif
  393.     )
  394. {
  395. }
  396.  
  397.  
  398. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  399. GCC_Key::operator GCC_H221NonStandardIdentifier &() const
  400. #else
  401. GCC_Key::operator GCC_H221NonStandardIdentifier &()
  402. {
  403. #ifndef PASN_LEANANDMEAN
  404.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_H221NonStandardIdentifier::Class()), PInvalidCast);
  405. #endif
  406.   return *(GCC_H221NonStandardIdentifier *)choice;
  407. }
  408.  
  409.  
  410. GCC_Key::operator const GCC_H221NonStandardIdentifier &() const
  411. #endif
  412. {
  413. #ifndef PASN_LEANANDMEAN
  414.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_H221NonStandardIdentifier::Class()), PInvalidCast);
  415. #endif
  416.   return *(GCC_H221NonStandardIdentifier *)choice;
  417. }
  418.  
  419.  
  420. BOOL GCC_Key::CreateObject()
  421. {
  422.   switch (tag) {
  423.     case e_object :
  424.       choice = new PASN_ObjectId();
  425.       return TRUE;
  426.     case e_h221NonStandard :
  427.       choice = new GCC_H221NonStandardIdentifier();
  428.       return TRUE;
  429.   }
  430.  
  431.   choice = NULL;
  432.   return FALSE;
  433. }
  434.  
  435.  
  436. PObject * GCC_Key::Clone() const
  437. {
  438. #ifndef PASN_LEANANDMEAN
  439.   PAssert(IsClass(GCC_Key::Class()), PInvalidCast);
  440. #endif
  441.   return new GCC_Key(*this);
  442. }
  443.  
  444.  
  445. //
  446. // NonStandardParameter
  447. //
  448.  
  449. GCC_NonStandardParameter::GCC_NonStandardParameter(unsigned tag, PASN_Object::TagClass tagClass)
  450.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  451. {
  452. }
  453.  
  454.  
  455. #ifndef PASN_NOPRINTON
  456. void GCC_NonStandardParameter::PrintOn(ostream & strm) const
  457. {
  458.   int indent = strm.precision() + 2;
  459.   strm << "{\n";
  460.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  461.   strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
  462.   strm << setw(indent-1) << "}";
  463. }
  464. #endif
  465.  
  466.  
  467. PObject::Comparison GCC_NonStandardParameter::Compare(const PObject & obj) const
  468. {
  469. #ifndef PASN_LEANANDMEAN
  470.   PAssert(IsDescendant(GCC_NonStandardParameter::Class()), PInvalidCast);
  471. #endif
  472.   const GCC_NonStandardParameter & other = (const GCC_NonStandardParameter &)obj;
  473.  
  474.   Comparison result;
  475.  
  476.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  477.     return result;
  478.   if ((result = m_data.Compare(other.m_data)) != EqualTo)
  479.     return result;
  480.  
  481.   return PASN_Sequence::Compare(other);
  482. }
  483.  
  484.  
  485. PINDEX GCC_NonStandardParameter::GetDataLength() const
  486. {
  487.   PINDEX length = 0;
  488.   length += m_key.GetObjectLength();
  489.   length += m_data.GetObjectLength();
  490.   return length;
  491. }
  492.  
  493.  
  494. BOOL GCC_NonStandardParameter::Decode(PASN_Stream & strm)
  495. {
  496.   if (!PreambleDecode(strm))
  497.     return FALSE;
  498.  
  499.   if (!m_key.Decode(strm))
  500.     return FALSE;
  501.   if (!m_data.Decode(strm))
  502.     return FALSE;
  503.  
  504.   return UnknownExtensionsDecode(strm);
  505. }
  506.  
  507.  
  508. void GCC_NonStandardParameter::Encode(PASN_Stream & strm) const
  509. {
  510.   PreambleEncode(strm);
  511.  
  512.   m_key.Encode(strm);
  513.   m_data.Encode(strm);
  514.  
  515.   UnknownExtensionsEncode(strm);
  516. }
  517.  
  518.  
  519. PObject * GCC_NonStandardParameter::Clone() const
  520. {
  521. #ifndef PASN_LEANANDMEAN
  522.   PAssert(IsClass(GCC_NonStandardParameter::Class()), PInvalidCast);
  523. #endif
  524.   return new GCC_NonStandardParameter(*this);
  525. }
  526.  
  527.  
  528. //
  529. // TextString
  530. //
  531.  
  532. GCC_TextString::GCC_TextString(unsigned tag, PASN_Object::TagClass tagClass)
  533.   : PASN_BMPString(tag, tagClass)
  534. {
  535.   SetConstraints(PASN_Object::FixedConstraint, 0, 255);
  536. }
  537.  
  538.  
  539. GCC_TextString & GCC_TextString::operator=(const char * v)
  540. {
  541.   SetValue(v);
  542.   return *this;
  543. }
  544.  
  545.  
  546. GCC_TextString & GCC_TextString::operator=(const PString & v)
  547. {
  548.   SetValue(v);
  549.   return *this;
  550. }
  551.  
  552.  
  553. GCC_TextString & GCC_TextString::operator=(const PWORDArray & v)
  554. {
  555.   SetValue(v);
  556.   return *this;
  557. }
  558.  
  559.  
  560. GCC_TextString & GCC_TextString::operator=(const PASN_BMPString & v)
  561. {
  562.   SetValue(v);
  563.   return *this;
  564. }
  565.  
  566.  
  567. PObject * GCC_TextString::Clone() const
  568. {
  569. #ifndef PASN_LEANANDMEAN
  570.   PAssert(IsClass(GCC_TextString::Class()), PInvalidCast);
  571. #endif
  572.   return new GCC_TextString(*this);
  573. }
  574.  
  575.  
  576. //
  577. // SimpleTextString
  578. //
  579.  
  580. GCC_SimpleTextString::GCC_SimpleTextString(unsigned tag, PASN_Object::TagClass tagClass)
  581.   : PASN_BMPString(tag, tagClass)
  582. {
  583.   SetConstraints(PASN_Object::FixedConstraint, 0, 255);
  584.   SetCharacterSet(PASN_Object::FixedConstraint, 0, 255);
  585. }
  586.  
  587.  
  588. GCC_SimpleTextString & GCC_SimpleTextString::operator=(const char * v)
  589. {
  590.   SetValue(v);
  591.   return *this;
  592. }
  593.  
  594.  
  595. GCC_SimpleTextString & GCC_SimpleTextString::operator=(const PString & v)
  596. {
  597.   SetValue(v);
  598.   return *this;
  599. }
  600.  
  601.  
  602. GCC_SimpleTextString & GCC_SimpleTextString::operator=(const PWORDArray & v)
  603. {
  604.   SetValue(v);
  605.   return *this;
  606. }
  607.  
  608.  
  609. GCC_SimpleTextString & GCC_SimpleTextString::operator=(const PASN_BMPString & v)
  610. {
  611.   SetValue(v);
  612.   return *this;
  613. }
  614.  
  615.  
  616. PObject * GCC_SimpleTextString::Clone() const
  617. {
  618. #ifndef PASN_LEANANDMEAN
  619.   PAssert(IsClass(GCC_SimpleTextString::Class()), PInvalidCast);
  620. #endif
  621.   return new GCC_SimpleTextString(*this);
  622. }
  623.  
  624.  
  625. //
  626. // SimpleNumericString
  627. //
  628.  
  629. GCC_SimpleNumericString::GCC_SimpleNumericString(unsigned tag, PASN_Object::TagClass tagClass)
  630.   : PASN_NumericString(tag, tagClass)
  631. {
  632.   SetConstraints(PASN_Object::FixedConstraint, 1, 255);
  633.   SetCharacterSet(PASN_Object::FixedConstraint, "0123456789");
  634. }
  635.  
  636.  
  637. GCC_SimpleNumericString & GCC_SimpleNumericString::operator=(const char * v)
  638. {
  639.   SetValue(v);
  640.   return *this;
  641. }
  642.  
  643.  
  644. GCC_SimpleNumericString & GCC_SimpleNumericString::operator=(const PString & v)
  645. {
  646.   SetValue(v);
  647.   return *this;
  648. }
  649.  
  650.  
  651. PObject * GCC_SimpleNumericString::Clone() const
  652. {
  653. #ifndef PASN_LEANANDMEAN
  654.   PAssert(IsClass(GCC_SimpleNumericString::Class()), PInvalidCast);
  655. #endif
  656.   return new GCC_SimpleNumericString(*this);
  657. }
  658.  
  659.  
  660. //
  661. // DialingString
  662. //
  663.  
  664. GCC_DialingString::GCC_DialingString(unsigned tag, PASN_Object::TagClass tagClass)
  665.   : PASN_NumericString(tag, tagClass)
  666. {
  667.   SetConstraints(PASN_Object::FixedConstraint, 1, 16);
  668.   SetCharacterSet(PASN_Object::FixedConstraint, "0123456789");
  669. }
  670.  
  671.  
  672. GCC_DialingString & GCC_DialingString::operator=(const char * v)
  673. {
  674.   SetValue(v);
  675.   return *this;
  676. }
  677.  
  678.  
  679. GCC_DialingString & GCC_DialingString::operator=(const PString & v)
  680. {
  681.   SetValue(v);
  682.   return *this;
  683. }
  684.  
  685.  
  686. PObject * GCC_DialingString::Clone() const
  687. {
  688. #ifndef PASN_LEANANDMEAN
  689.   PAssert(IsClass(GCC_DialingString::Class()), PInvalidCast);
  690. #endif
  691.   return new GCC_DialingString(*this);
  692. }
  693.  
  694.  
  695. //
  696. // SubAddressString
  697. //
  698.  
  699. GCC_SubAddressString::GCC_SubAddressString(unsigned tag, PASN_Object::TagClass tagClass)
  700.   : PASN_NumericString(tag, tagClass)
  701. {
  702.   SetConstraints(PASN_Object::FixedConstraint, 1, 40);
  703.   SetCharacterSet(PASN_Object::FixedConstraint, "0123456789");
  704. }
  705.  
  706.  
  707. GCC_SubAddressString & GCC_SubAddressString::operator=(const char * v)
  708. {
  709.   SetValue(v);
  710.   return *this;
  711. }
  712.  
  713.  
  714. GCC_SubAddressString & GCC_SubAddressString::operator=(const PString & v)
  715. {
  716.   SetValue(v);
  717.   return *this;
  718. }
  719.  
  720.  
  721. PObject * GCC_SubAddressString::Clone() const
  722. {
  723. #ifndef PASN_LEANANDMEAN
  724.   PAssert(IsClass(GCC_SubAddressString::Class()), PInvalidCast);
  725. #endif
  726.   return new GCC_SubAddressString(*this);
  727. }
  728.  
  729.  
  730. //
  731. // ExtraDialingString
  732. //
  733.  
  734. GCC_ExtraDialingString::GCC_ExtraDialingString(unsigned tag, PASN_Object::TagClass tagClass)
  735.   : PASN_BMPString(tag, tagClass)
  736. {
  737.   SetConstraints(PASN_Object::FixedConstraint, 1, 255);
  738.   SetCharacterSet(PASN_Object::FixedConstraint, "0123456789#*,");
  739. }
  740.  
  741.  
  742. GCC_ExtraDialingString & GCC_ExtraDialingString::operator=(const char * v)
  743. {
  744.   SetValue(v);
  745.   return *this;
  746. }
  747.  
  748.  
  749. GCC_ExtraDialingString & GCC_ExtraDialingString::operator=(const PString & v)
  750. {
  751.   SetValue(v);
  752.   return *this;
  753. }
  754.  
  755.  
  756. GCC_ExtraDialingString & GCC_ExtraDialingString::operator=(const PWORDArray & v)
  757. {
  758.   SetValue(v);
  759.   return *this;
  760. }
  761.  
  762.  
  763. GCC_ExtraDialingString & GCC_ExtraDialingString::operator=(const PASN_BMPString & v)
  764. {
  765.   SetValue(v);
  766.   return *this;
  767. }
  768.  
  769.  
  770. PObject * GCC_ExtraDialingString::Clone() const
  771. {
  772. #ifndef PASN_LEANANDMEAN
  773.   PAssert(IsClass(GCC_ExtraDialingString::Class()), PInvalidCast);
  774. #endif
  775.   return new GCC_ExtraDialingString(*this);
  776. }
  777.  
  778.  
  779. //
  780. // UserData
  781. //
  782.  
  783. GCC_UserData::GCC_UserData(unsigned tag, PASN_Object::TagClass tagClass)
  784.   : PASN_Array(tag, tagClass)
  785. {
  786. }
  787.  
  788.  
  789. PASN_Object * GCC_UserData::CreateObject() const
  790. {
  791.   return new GCC_UserData_subtype;
  792. }
  793.  
  794.  
  795. GCC_UserData_subtype & GCC_UserData::operator[](PINDEX i) const
  796. {
  797.   return (GCC_UserData_subtype &)array[i];
  798. }
  799.  
  800.  
  801. PObject * GCC_UserData::Clone() const
  802. {
  803. #ifndef PASN_LEANANDMEAN
  804.   PAssert(IsClass(GCC_UserData::Class()), PInvalidCast);
  805. #endif
  806.   return new GCC_UserData(*this);
  807. }
  808.  
  809.  
  810. //
  811. // Password
  812. //
  813.  
  814. GCC_Password::GCC_Password(unsigned tag, PASN_Object::TagClass tagClass)
  815.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  816. {
  817. }
  818.  
  819.  
  820. #ifndef PASN_NOPRINTON
  821. void GCC_Password::PrintOn(ostream & strm) const
  822. {
  823.   int indent = strm.precision() + 2;
  824.   strm << "{\n";
  825.   strm << setw(indent+10) << "numeric = " << setprecision(indent) << m_numeric << '\n';
  826.   if (HasOptionalField(e_text))
  827.     strm << setw(indent+7) << "text = " << setprecision(indent) << m_text << '\n';
  828.   strm << setw(indent-1) << "}";
  829. }
  830. #endif
  831.  
  832.  
  833. PObject::Comparison GCC_Password::Compare(const PObject & obj) const
  834. {
  835. #ifndef PASN_LEANANDMEAN
  836.   PAssert(IsDescendant(GCC_Password::Class()), PInvalidCast);
  837. #endif
  838.   const GCC_Password & other = (const GCC_Password &)obj;
  839.  
  840.   Comparison result;
  841.  
  842.   if ((result = m_numeric.Compare(other.m_numeric)) != EqualTo)
  843.     return result;
  844.   if ((result = m_text.Compare(other.m_text)) != EqualTo)
  845.     return result;
  846.  
  847.   return PASN_Sequence::Compare(other);
  848. }
  849.  
  850.  
  851. PINDEX GCC_Password::GetDataLength() const
  852. {
  853.   PINDEX length = 0;
  854.   length += m_numeric.GetObjectLength();
  855.   if (HasOptionalField(e_text))
  856.     length += m_text.GetObjectLength();
  857.   return length;
  858. }
  859.  
  860.  
  861. BOOL GCC_Password::Decode(PASN_Stream & strm)
  862. {
  863.   if (!PreambleDecode(strm))
  864.     return FALSE;
  865.  
  866.   if (!m_numeric.Decode(strm))
  867.     return FALSE;
  868.   if (HasOptionalField(e_text) && !m_text.Decode(strm))
  869.     return FALSE;
  870.  
  871.   return UnknownExtensionsDecode(strm);
  872. }
  873.  
  874.  
  875. void GCC_Password::Encode(PASN_Stream & strm) const
  876. {
  877.   PreambleEncode(strm);
  878.  
  879.   m_numeric.Encode(strm);
  880.   if (HasOptionalField(e_text))
  881.     m_text.Encode(strm);
  882.  
  883.   UnknownExtensionsEncode(strm);
  884. }
  885.  
  886.  
  887. PObject * GCC_Password::Clone() const
  888. {
  889. #ifndef PASN_LEANANDMEAN
  890.   PAssert(IsClass(GCC_Password::Class()), PInvalidCast);
  891. #endif
  892.   return new GCC_Password(*this);
  893. }
  894.  
  895.  
  896. //
  897. // PasswordSelector
  898. //
  899.  
  900. GCC_PasswordSelector::GCC_PasswordSelector(unsigned tag, PASN_Object::TagClass tagClass)
  901.   : PASN_Choice(tag, tagClass, 2, TRUE
  902. #ifndef PASN_NOPRINTON
  903.       , "numeric "
  904.         "text "
  905. #endif
  906.     )
  907. {
  908. }
  909.  
  910.  
  911. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  912. GCC_PasswordSelector::operator GCC_SimpleNumericString &() const
  913. #else
  914. GCC_PasswordSelector::operator GCC_SimpleNumericString &()
  915. {
  916. #ifndef PASN_LEANANDMEAN
  917.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_SimpleNumericString::Class()), PInvalidCast);
  918. #endif
  919.   return *(GCC_SimpleNumericString *)choice;
  920. }
  921.  
  922.  
  923. GCC_PasswordSelector::operator const GCC_SimpleNumericString &() const
  924. #endif
  925. {
  926. #ifndef PASN_LEANANDMEAN
  927.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_SimpleNumericString::Class()), PInvalidCast);
  928. #endif
  929.   return *(GCC_SimpleNumericString *)choice;
  930. }
  931.  
  932.  
  933. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  934. GCC_PasswordSelector::operator GCC_SimpleTextString &() const
  935. #else
  936. GCC_PasswordSelector::operator GCC_SimpleTextString &()
  937. {
  938. #ifndef PASN_LEANANDMEAN
  939.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_SimpleTextString::Class()), PInvalidCast);
  940. #endif
  941.   return *(GCC_SimpleTextString *)choice;
  942. }
  943.  
  944.  
  945. GCC_PasswordSelector::operator const GCC_SimpleTextString &() const
  946. #endif
  947. {
  948. #ifndef PASN_LEANANDMEAN
  949.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_SimpleTextString::Class()), PInvalidCast);
  950. #endif
  951.   return *(GCC_SimpleTextString *)choice;
  952. }
  953.  
  954.  
  955. BOOL GCC_PasswordSelector::CreateObject()
  956. {
  957.   switch (tag) {
  958.     case e_numeric :
  959.       choice = new GCC_SimpleNumericString();
  960.       return TRUE;
  961.     case e_text :
  962.       choice = new GCC_SimpleTextString();
  963.       return TRUE;
  964.   }
  965.  
  966.   choice = NULL;
  967.   return FALSE;
  968. }
  969.  
  970.  
  971. PObject * GCC_PasswordSelector::Clone() const
  972. {
  973. #ifndef PASN_LEANANDMEAN
  974.   PAssert(IsClass(GCC_PasswordSelector::Class()), PInvalidCast);
  975. #endif
  976.   return new GCC_PasswordSelector(*this);
  977. }
  978.  
  979.  
  980. //
  981. // ChallengeResponseItem
  982. //
  983.  
  984. GCC_ChallengeResponseItem::GCC_ChallengeResponseItem(unsigned tag, PASN_Object::TagClass tagClass)
  985.   : PASN_Choice(tag, tagClass, 2, TRUE
  986. #ifndef PASN_NOPRINTON
  987.       , "passwordString "
  988.         "responseData "
  989. #endif
  990.     )
  991. {
  992. }
  993.  
  994.  
  995. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  996. GCC_ChallengeResponseItem::operator GCC_PasswordSelector &() const
  997. #else
  998. GCC_ChallengeResponseItem::operator GCC_PasswordSelector &()
  999. {
  1000. #ifndef PASN_LEANANDMEAN
  1001.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_PasswordSelector::Class()), PInvalidCast);
  1002. #endif
  1003.   return *(GCC_PasswordSelector *)choice;
  1004. }
  1005.  
  1006.  
  1007. GCC_ChallengeResponseItem::operator const GCC_PasswordSelector &() const
  1008. #endif
  1009. {
  1010. #ifndef PASN_LEANANDMEAN
  1011.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_PasswordSelector::Class()), PInvalidCast);
  1012. #endif
  1013.   return *(GCC_PasswordSelector *)choice;
  1014. }
  1015.  
  1016.  
  1017. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1018. GCC_ChallengeResponseItem::operator GCC_UserData &() const
  1019. #else
  1020. GCC_ChallengeResponseItem::operator GCC_UserData &()
  1021. {
  1022. #ifndef PASN_LEANANDMEAN
  1023.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_UserData::Class()), PInvalidCast);
  1024. #endif
  1025.   return *(GCC_UserData *)choice;
  1026. }
  1027.  
  1028.  
  1029. GCC_ChallengeResponseItem::operator const GCC_UserData &() const
  1030. #endif
  1031. {
  1032. #ifndef PASN_LEANANDMEAN
  1033.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_UserData::Class()), PInvalidCast);
  1034. #endif
  1035.   return *(GCC_UserData *)choice;
  1036. }
  1037.  
  1038.  
  1039. BOOL GCC_ChallengeResponseItem::CreateObject()
  1040. {
  1041.   switch (tag) {
  1042.     case e_passwordString :
  1043.       choice = new GCC_PasswordSelector();
  1044.       return TRUE;
  1045.     case e_responseData :
  1046.       choice = new GCC_UserData();
  1047.       return TRUE;
  1048.   }
  1049.  
  1050.   choice = NULL;
  1051.   return FALSE;
  1052. }
  1053.  
  1054.  
  1055. PObject * GCC_ChallengeResponseItem::Clone() const
  1056. {
  1057. #ifndef PASN_LEANANDMEAN
  1058.   PAssert(IsClass(GCC_ChallengeResponseItem::Class()), PInvalidCast);
  1059. #endif
  1060.   return new GCC_ChallengeResponseItem(*this);
  1061. }
  1062.  
  1063.  
  1064. //
  1065. // ChallengeResponseAlgorithm
  1066. //
  1067.  
  1068. GCC_ChallengeResponseAlgorithm::GCC_ChallengeResponseAlgorithm(unsigned tag, PASN_Object::TagClass tagClass)
  1069.   : PASN_Choice(tag, tagClass, 2, TRUE
  1070. #ifndef PASN_NOPRINTON
  1071.       , "passwordInTheClear "
  1072.         "nonStandardAlgorithm "
  1073. #endif
  1074.     )
  1075. {
  1076. }
  1077.  
  1078.  
  1079. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1080. GCC_ChallengeResponseAlgorithm::operator GCC_NonStandardParameter &() const
  1081. #else
  1082. GCC_ChallengeResponseAlgorithm::operator GCC_NonStandardParameter &()
  1083. {
  1084. #ifndef PASN_LEANANDMEAN
  1085.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardParameter::Class()), PInvalidCast);
  1086. #endif
  1087.   return *(GCC_NonStandardParameter *)choice;
  1088. }
  1089.  
  1090.  
  1091. GCC_ChallengeResponseAlgorithm::operator const GCC_NonStandardParameter &() const
  1092. #endif
  1093. {
  1094. #ifndef PASN_LEANANDMEAN
  1095.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardParameter::Class()), PInvalidCast);
  1096. #endif
  1097.   return *(GCC_NonStandardParameter *)choice;
  1098. }
  1099.  
  1100.  
  1101. BOOL GCC_ChallengeResponseAlgorithm::CreateObject()
  1102. {
  1103.   switch (tag) {
  1104.     case e_passwordInTheClear :
  1105.       choice = new PASN_Null();
  1106.       return TRUE;
  1107.     case e_nonStandardAlgorithm :
  1108.       choice = new GCC_NonStandardParameter();
  1109.       return TRUE;
  1110.   }
  1111.  
  1112.   choice = NULL;
  1113.   return FALSE;
  1114. }
  1115.  
  1116.  
  1117. PObject * GCC_ChallengeResponseAlgorithm::Clone() const
  1118. {
  1119. #ifndef PASN_LEANANDMEAN
  1120.   PAssert(IsClass(GCC_ChallengeResponseAlgorithm::Class()), PInvalidCast);
  1121. #endif
  1122.   return new GCC_ChallengeResponseAlgorithm(*this);
  1123. }
  1124.  
  1125.  
  1126. //
  1127. // ChallengeItem
  1128. //
  1129.  
  1130. GCC_ChallengeItem::GCC_ChallengeItem(unsigned tag, PASN_Object::TagClass tagClass)
  1131.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  1132. {
  1133. }
  1134.  
  1135.  
  1136. #ifndef PASN_NOPRINTON
  1137. void GCC_ChallengeItem::PrintOn(ostream & strm) const
  1138. {
  1139.   int indent = strm.precision() + 2;
  1140.   strm << "{\n";
  1141.   strm << setw(indent+20) << "responseAlgorithm = " << setprecision(indent) << m_responseAlgorithm << '\n';
  1142.   strm << setw(indent+16) << "challengeData = " << setprecision(indent) << m_challengeData << '\n';
  1143.   strm << setw(indent-1) << "}";
  1144. }
  1145. #endif
  1146.  
  1147.  
  1148. PObject::Comparison GCC_ChallengeItem::Compare(const PObject & obj) const
  1149. {
  1150. #ifndef PASN_LEANANDMEAN
  1151.   PAssert(IsDescendant(GCC_ChallengeItem::Class()), PInvalidCast);
  1152. #endif
  1153.   const GCC_ChallengeItem & other = (const GCC_ChallengeItem &)obj;
  1154.  
  1155.   Comparison result;
  1156.  
  1157.   if ((result = m_responseAlgorithm.Compare(other.m_responseAlgorithm)) != EqualTo)
  1158.     return result;
  1159.   if ((result = m_challengeData.Compare(other.m_challengeData)) != EqualTo)
  1160.     return result;
  1161.  
  1162.   return PASN_Sequence::Compare(other);
  1163. }
  1164.  
  1165.  
  1166. PINDEX GCC_ChallengeItem::GetDataLength() const
  1167. {
  1168.   PINDEX length = 0;
  1169.   length += m_responseAlgorithm.GetObjectLength();
  1170.   length += m_challengeData.GetObjectLength();
  1171.   return length;
  1172. }
  1173.  
  1174.  
  1175. BOOL GCC_ChallengeItem::Decode(PASN_Stream & strm)
  1176. {
  1177.   if (!PreambleDecode(strm))
  1178.     return FALSE;
  1179.  
  1180.   if (!m_responseAlgorithm.Decode(strm))
  1181.     return FALSE;
  1182.   if (!m_challengeData.Decode(strm))
  1183.     return FALSE;
  1184.  
  1185.   return UnknownExtensionsDecode(strm);
  1186. }
  1187.  
  1188.  
  1189. void GCC_ChallengeItem::Encode(PASN_Stream & strm) const
  1190. {
  1191.   PreambleEncode(strm);
  1192.  
  1193.   m_responseAlgorithm.Encode(strm);
  1194.   m_challengeData.Encode(strm);
  1195.  
  1196.   UnknownExtensionsEncode(strm);
  1197. }
  1198.  
  1199.  
  1200. PObject * GCC_ChallengeItem::Clone() const
  1201. {
  1202. #ifndef PASN_LEANANDMEAN
  1203.   PAssert(IsClass(GCC_ChallengeItem::Class()), PInvalidCast);
  1204. #endif
  1205.   return new GCC_ChallengeItem(*this);
  1206. }
  1207.  
  1208.  
  1209. //
  1210. // ChallengeResponse
  1211. //
  1212.  
  1213. GCC_ChallengeResponse::GCC_ChallengeResponse(unsigned tag, PASN_Object::TagClass tagClass)
  1214.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  1215. {
  1216. }
  1217.  
  1218.  
  1219. #ifndef PASN_NOPRINTON
  1220. void GCC_ChallengeResponse::PrintOn(ostream & strm) const
  1221. {
  1222.   int indent = strm.precision() + 2;
  1223.   strm << "{\n";
  1224.   strm << setw(indent+15) << "challengeTag = " << setprecision(indent) << m_challengeTag << '\n';
  1225.   strm << setw(indent+20) << "responseAlgorithm = " << setprecision(indent) << m_responseAlgorithm << '\n';
  1226.   strm << setw(indent+15) << "responseItem = " << setprecision(indent) << m_responseItem << '\n';
  1227.   strm << setw(indent-1) << "}";
  1228. }
  1229. #endif
  1230.  
  1231.  
  1232. PObject::Comparison GCC_ChallengeResponse::Compare(const PObject & obj) const
  1233. {
  1234. #ifndef PASN_LEANANDMEAN
  1235.   PAssert(IsDescendant(GCC_ChallengeResponse::Class()), PInvalidCast);
  1236. #endif
  1237.   const GCC_ChallengeResponse & other = (const GCC_ChallengeResponse &)obj;
  1238.  
  1239.   Comparison result;
  1240.  
  1241.   if ((result = m_challengeTag.Compare(other.m_challengeTag)) != EqualTo)
  1242.     return result;
  1243.   if ((result = m_responseAlgorithm.Compare(other.m_responseAlgorithm)) != EqualTo)
  1244.     return result;
  1245.   if ((result = m_responseItem.Compare(other.m_responseItem)) != EqualTo)
  1246.     return result;
  1247.  
  1248.   return PASN_Sequence::Compare(other);
  1249. }
  1250.  
  1251.  
  1252. PINDEX GCC_ChallengeResponse::GetDataLength() const
  1253. {
  1254.   PINDEX length = 0;
  1255.   length += m_challengeTag.GetObjectLength();
  1256.   length += m_responseAlgorithm.GetObjectLength();
  1257.   length += m_responseItem.GetObjectLength();
  1258.   return length;
  1259. }
  1260.  
  1261.  
  1262. BOOL GCC_ChallengeResponse::Decode(PASN_Stream & strm)
  1263. {
  1264.   if (!PreambleDecode(strm))
  1265.     return FALSE;
  1266.  
  1267.   if (!m_challengeTag.Decode(strm))
  1268.     return FALSE;
  1269.   if (!m_responseAlgorithm.Decode(strm))
  1270.     return FALSE;
  1271.   if (!m_responseItem.Decode(strm))
  1272.     return FALSE;
  1273.  
  1274.   return UnknownExtensionsDecode(strm);
  1275. }
  1276.  
  1277.  
  1278. void GCC_ChallengeResponse::Encode(PASN_Stream & strm) const
  1279. {
  1280.   PreambleEncode(strm);
  1281.  
  1282.   m_challengeTag.Encode(strm);
  1283.   m_responseAlgorithm.Encode(strm);
  1284.   m_responseItem.Encode(strm);
  1285.  
  1286.   UnknownExtensionsEncode(strm);
  1287. }
  1288.  
  1289.  
  1290. PObject * GCC_ChallengeResponse::Clone() const
  1291. {
  1292. #ifndef PASN_LEANANDMEAN
  1293.   PAssert(IsClass(GCC_ChallengeResponse::Class()), PInvalidCast);
  1294. #endif
  1295.   return new GCC_ChallengeResponse(*this);
  1296. }
  1297.  
  1298.  
  1299. //
  1300. // PasswordChallengeRequestResponse
  1301. //
  1302.  
  1303. GCC_PasswordChallengeRequestResponse::GCC_PasswordChallengeRequestResponse(unsigned tag, PASN_Object::TagClass tagClass)
  1304.   : PASN_Choice(tag, tagClass, 2, TRUE
  1305. #ifndef PASN_NOPRINTON
  1306.       , "passwordInTheClear "
  1307.         "challengeRequestResponse "
  1308. #endif
  1309.     )
  1310. {
  1311. }
  1312.  
  1313.  
  1314. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1315. GCC_PasswordChallengeRequestResponse::operator GCC_PasswordSelector &() const
  1316. #else
  1317. GCC_PasswordChallengeRequestResponse::operator GCC_PasswordSelector &()
  1318. {
  1319. #ifndef PASN_LEANANDMEAN
  1320.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_PasswordSelector::Class()), PInvalidCast);
  1321. #endif
  1322.   return *(GCC_PasswordSelector *)choice;
  1323. }
  1324.  
  1325.  
  1326. GCC_PasswordChallengeRequestResponse::operator const GCC_PasswordSelector &() const
  1327. #endif
  1328. {
  1329. #ifndef PASN_LEANANDMEAN
  1330.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_PasswordSelector::Class()), PInvalidCast);
  1331. #endif
  1332.   return *(GCC_PasswordSelector *)choice;
  1333. }
  1334.  
  1335.  
  1336. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1337. GCC_PasswordChallengeRequestResponse::operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const
  1338. #else
  1339. GCC_PasswordChallengeRequestResponse::operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &()
  1340. {
  1341. #ifndef PASN_LEANANDMEAN
  1342.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_PasswordChallengeRequestResponse_challengeRequestResponse::Class()), PInvalidCast);
  1343. #endif
  1344.   return *(GCC_PasswordChallengeRequestResponse_challengeRequestResponse *)choice;
  1345. }
  1346.  
  1347.  
  1348. GCC_PasswordChallengeRequestResponse::operator const GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const
  1349. #endif
  1350. {
  1351. #ifndef PASN_LEANANDMEAN
  1352.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_PasswordChallengeRequestResponse_challengeRequestResponse::Class()), PInvalidCast);
  1353. #endif
  1354.   return *(GCC_PasswordChallengeRequestResponse_challengeRequestResponse *)choice;
  1355. }
  1356.  
  1357.  
  1358. BOOL GCC_PasswordChallengeRequestResponse::CreateObject()
  1359. {
  1360.   switch (tag) {
  1361.     case e_passwordInTheClear :
  1362.       choice = new GCC_PasswordSelector();
  1363.       return TRUE;
  1364.     case e_challengeRequestResponse :
  1365.       choice = new GCC_PasswordChallengeRequestResponse_challengeRequestResponse();
  1366.       return TRUE;
  1367.   }
  1368.  
  1369.   choice = NULL;
  1370.   return FALSE;
  1371. }
  1372.  
  1373.  
  1374. PObject * GCC_PasswordChallengeRequestResponse::Clone() const
  1375. {
  1376. #ifndef PASN_LEANANDMEAN
  1377.   PAssert(IsClass(GCC_PasswordChallengeRequestResponse::Class()), PInvalidCast);
  1378. #endif
  1379.   return new GCC_PasswordChallengeRequestResponse(*this);
  1380. }
  1381.  
  1382.  
  1383. //
  1384. // ConferenceName
  1385. //
  1386.  
  1387. GCC_ConferenceName::GCC_ConferenceName(unsigned tag, PASN_Object::TagClass tagClass)
  1388.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  1389. {
  1390. }
  1391.  
  1392.  
  1393. #ifndef PASN_NOPRINTON
  1394. void GCC_ConferenceName::PrintOn(ostream & strm) const
  1395. {
  1396.   int indent = strm.precision() + 2;
  1397.   strm << "{\n";
  1398.   strm << setw(indent+10) << "numeric = " << setprecision(indent) << m_numeric << '\n';
  1399.   if (HasOptionalField(e_text))
  1400.     strm << setw(indent+7) << "text = " << setprecision(indent) << m_text << '\n';
  1401.   strm << setw(indent-1) << "}";
  1402. }
  1403. #endif
  1404.  
  1405.  
  1406. PObject::Comparison GCC_ConferenceName::Compare(const PObject & obj) const
  1407. {
  1408. #ifndef PASN_LEANANDMEAN
  1409.   PAssert(IsDescendant(GCC_ConferenceName::Class()), PInvalidCast);
  1410. #endif
  1411.   const GCC_ConferenceName & other = (const GCC_ConferenceName &)obj;
  1412.  
  1413.   Comparison result;
  1414.  
  1415.   if ((result = m_numeric.Compare(other.m_numeric)) != EqualTo)
  1416.     return result;
  1417.   if ((result = m_text.Compare(other.m_text)) != EqualTo)
  1418.     return result;
  1419.  
  1420.   return PASN_Sequence::Compare(other);
  1421. }
  1422.  
  1423.  
  1424. PINDEX GCC_ConferenceName::GetDataLength() const
  1425. {
  1426.   PINDEX length = 0;
  1427.   length += m_numeric.GetObjectLength();
  1428.   if (HasOptionalField(e_text))
  1429.     length += m_text.GetObjectLength();
  1430.   return length;
  1431. }
  1432.  
  1433.  
  1434. BOOL GCC_ConferenceName::Decode(PASN_Stream & strm)
  1435. {
  1436.   if (!PreambleDecode(strm))
  1437.     return FALSE;
  1438.  
  1439.   if (!m_numeric.Decode(strm))
  1440.     return FALSE;
  1441.   if (HasOptionalField(e_text) && !m_text.Decode(strm))
  1442.     return FALSE;
  1443.  
  1444.   return UnknownExtensionsDecode(strm);
  1445. }
  1446.  
  1447.  
  1448. void GCC_ConferenceName::Encode(PASN_Stream & strm) const
  1449. {
  1450.   PreambleEncode(strm);
  1451.  
  1452.   m_numeric.Encode(strm);
  1453.   if (HasOptionalField(e_text))
  1454.     m_text.Encode(strm);
  1455.  
  1456.   UnknownExtensionsEncode(strm);
  1457. }
  1458.  
  1459.  
  1460. PObject * GCC_ConferenceName::Clone() const
  1461. {
  1462. #ifndef PASN_LEANANDMEAN
  1463.   PAssert(IsClass(GCC_ConferenceName::Class()), PInvalidCast);
  1464. #endif
  1465.   return new GCC_ConferenceName(*this);
  1466. }
  1467.  
  1468.  
  1469. //
  1470. // ConferenceNameSelector
  1471. //
  1472.  
  1473. GCC_ConferenceNameSelector::GCC_ConferenceNameSelector(unsigned tag, PASN_Object::TagClass tagClass)
  1474.   : PASN_Choice(tag, tagClass, 2, TRUE
  1475. #ifndef PASN_NOPRINTON
  1476.       , "numeric "
  1477.         "text "
  1478. #endif
  1479.     )
  1480. {
  1481. }
  1482.  
  1483.  
  1484. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1485. GCC_ConferenceNameSelector::operator GCC_SimpleNumericString &() const
  1486. #else
  1487. GCC_ConferenceNameSelector::operator GCC_SimpleNumericString &()
  1488. {
  1489. #ifndef PASN_LEANANDMEAN
  1490.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_SimpleNumericString::Class()), PInvalidCast);
  1491. #endif
  1492.   return *(GCC_SimpleNumericString *)choice;
  1493. }
  1494.  
  1495.  
  1496. GCC_ConferenceNameSelector::operator const GCC_SimpleNumericString &() const
  1497. #endif
  1498. {
  1499. #ifndef PASN_LEANANDMEAN
  1500.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_SimpleNumericString::Class()), PInvalidCast);
  1501. #endif
  1502.   return *(GCC_SimpleNumericString *)choice;
  1503. }
  1504.  
  1505.  
  1506. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1507. GCC_ConferenceNameSelector::operator GCC_SimpleTextString &() const
  1508. #else
  1509. GCC_ConferenceNameSelector::operator GCC_SimpleTextString &()
  1510. {
  1511. #ifndef PASN_LEANANDMEAN
  1512.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_SimpleTextString::Class()), PInvalidCast);
  1513. #endif
  1514.   return *(GCC_SimpleTextString *)choice;
  1515. }
  1516.  
  1517.  
  1518. GCC_ConferenceNameSelector::operator const GCC_SimpleTextString &() const
  1519. #endif
  1520. {
  1521. #ifndef PASN_LEANANDMEAN
  1522.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_SimpleTextString::Class()), PInvalidCast);
  1523. #endif
  1524.   return *(GCC_SimpleTextString *)choice;
  1525. }
  1526.  
  1527.  
  1528. BOOL GCC_ConferenceNameSelector::CreateObject()
  1529. {
  1530.   switch (tag) {
  1531.     case e_numeric :
  1532.       choice = new GCC_SimpleNumericString();
  1533.       return TRUE;
  1534.     case e_text :
  1535.       choice = new GCC_SimpleTextString();
  1536.       return TRUE;
  1537.   }
  1538.  
  1539.   choice = NULL;
  1540.   return FALSE;
  1541. }
  1542.  
  1543.  
  1544. PObject * GCC_ConferenceNameSelector::Clone() const
  1545. {
  1546. #ifndef PASN_LEANANDMEAN
  1547.   PAssert(IsClass(GCC_ConferenceNameSelector::Class()), PInvalidCast);
  1548. #endif
  1549.   return new GCC_ConferenceNameSelector(*this);
  1550. }
  1551.  
  1552.  
  1553. //
  1554. // ConferenceNameModifier
  1555. //
  1556.  
  1557. GCC_ConferenceNameModifier::GCC_ConferenceNameModifier(unsigned tag, PASN_Object::TagClass tagClass)
  1558.   : GCC_SimpleNumericString(tag, tagClass)
  1559. {
  1560. }
  1561.  
  1562.  
  1563. GCC_ConferenceNameModifier & GCC_ConferenceNameModifier::operator=(const char * v)
  1564. {
  1565.   SetValue(v);
  1566.   return *this;
  1567. }
  1568.  
  1569.  
  1570. GCC_ConferenceNameModifier & GCC_ConferenceNameModifier::operator=(const PString & v)
  1571. {
  1572.   SetValue(v);
  1573.   return *this;
  1574. }
  1575.  
  1576.  
  1577. PObject * GCC_ConferenceNameModifier::Clone() const
  1578. {
  1579. #ifndef PASN_LEANANDMEAN
  1580.   PAssert(IsClass(GCC_ConferenceNameModifier::Class()), PInvalidCast);
  1581. #endif
  1582.   return new GCC_ConferenceNameModifier(*this);
  1583. }
  1584.  
  1585.  
  1586. //
  1587. // Privilege
  1588. //
  1589.  
  1590. GCC_Privilege::GCC_Privilege(unsigned tag, PASN_Object::TagClass tagClass)
  1591.   : PASN_Enumeration(tag, tagClass, 4, TRUE
  1592. #ifndef PASN_NOPRINTON
  1593.       , "terminate "
  1594.         "ejectUser "
  1595.         "add "
  1596.         "lockUnlock "
  1597.         "transfer "
  1598. #endif
  1599.     )
  1600. {
  1601. }
  1602.  
  1603.  
  1604. GCC_Privilege & GCC_Privilege::operator=(unsigned v)
  1605. {
  1606.   SetValue(v);
  1607.   return *this;
  1608. }
  1609.  
  1610.  
  1611. PObject * GCC_Privilege::Clone() const
  1612. {
  1613. #ifndef PASN_LEANANDMEAN
  1614.   PAssert(IsClass(GCC_Privilege::Class()), PInvalidCast);
  1615. #endif
  1616.   return new GCC_Privilege(*this);
  1617. }
  1618.  
  1619.  
  1620. //
  1621. // TerminationMethod
  1622. //
  1623.  
  1624. GCC_TerminationMethod::GCC_TerminationMethod(unsigned tag, PASN_Object::TagClass tagClass)
  1625.   : PASN_Enumeration(tag, tagClass, 1, TRUE
  1626. #ifndef PASN_NOPRINTON
  1627.       , "automatic "
  1628.         "manual "
  1629. #endif
  1630.     )
  1631. {
  1632. }
  1633.  
  1634.  
  1635. GCC_TerminationMethod & GCC_TerminationMethod::operator=(unsigned v)
  1636. {
  1637.   SetValue(v);
  1638.   return *this;
  1639. }
  1640.  
  1641.  
  1642. PObject * GCC_TerminationMethod::Clone() const
  1643. {
  1644. #ifndef PASN_LEANANDMEAN
  1645.   PAssert(IsClass(GCC_TerminationMethod::Class()), PInvalidCast);
  1646. #endif
  1647.   return new GCC_TerminationMethod(*this);
  1648. }
  1649.  
  1650.  
  1651. //
  1652. // ConferencePriorityScheme
  1653. //
  1654.  
  1655. GCC_ConferencePriorityScheme::GCC_ConferencePriorityScheme(unsigned tag, PASN_Object::TagClass tagClass)
  1656.   : PASN_Choice(tag, tagClass, 1, TRUE
  1657. #ifndef PASN_NOPRINTON
  1658.       , "nonStandardScheme "
  1659. #endif
  1660.     )
  1661. {
  1662. }
  1663.  
  1664.  
  1665. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  1666. GCC_ConferencePriorityScheme::operator GCC_NonStandardParameter &() const
  1667. #else
  1668. GCC_ConferencePriorityScheme::operator GCC_NonStandardParameter &()
  1669. {
  1670. #ifndef PASN_LEANANDMEAN
  1671.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardParameter::Class()), PInvalidCast);
  1672. #endif
  1673.   return *(GCC_NonStandardParameter *)choice;
  1674. }
  1675.  
  1676.  
  1677. GCC_ConferencePriorityScheme::operator const GCC_NonStandardParameter &() const
  1678. #endif
  1679. {
  1680. #ifndef PASN_LEANANDMEAN
  1681.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardParameter::Class()), PInvalidCast);
  1682. #endif
  1683.   return *(GCC_NonStandardParameter *)choice;
  1684. }
  1685.  
  1686.  
  1687. BOOL GCC_ConferencePriorityScheme::CreateObject()
  1688. {
  1689.   switch (tag) {
  1690.     case e_nonStandardScheme :
  1691.       choice = new GCC_NonStandardParameter();
  1692.       return TRUE;
  1693.   }
  1694.  
  1695.   choice = NULL;
  1696.   return FALSE;
  1697. }
  1698.  
  1699.  
  1700. PObject * GCC_ConferencePriorityScheme::Clone() const
  1701. {
  1702. #ifndef PASN_LEANANDMEAN
  1703.   PAssert(IsClass(GCC_ConferencePriorityScheme::Class()), PInvalidCast);
  1704. #endif
  1705.   return new GCC_ConferencePriorityScheme(*this);
  1706. }
  1707.  
  1708.  
  1709. //
  1710. // ConferencePriority
  1711. //
  1712.  
  1713. GCC_ConferencePriority::GCC_ConferencePriority(unsigned tag, PASN_Object::TagClass tagClass)
  1714.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  1715. {
  1716.   m_priority.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  1717. }
  1718.  
  1719.  
  1720. #ifndef PASN_NOPRINTON
  1721. void GCC_ConferencePriority::PrintOn(ostream & strm) const
  1722. {
  1723.   int indent = strm.precision() + 2;
  1724.   strm << "{\n";
  1725.   strm << setw(indent+11) << "priority = " << setprecision(indent) << m_priority << '\n';
  1726.   strm << setw(indent+9) << "scheme = " << setprecision(indent) << m_scheme << '\n';
  1727.   strm << setw(indent-1) << "}";
  1728. }
  1729. #endif
  1730.  
  1731.  
  1732. PObject::Comparison GCC_ConferencePriority::Compare(const PObject & obj) const
  1733. {
  1734. #ifndef PASN_LEANANDMEAN
  1735.   PAssert(IsDescendant(GCC_ConferencePriority::Class()), PInvalidCast);
  1736. #endif
  1737.   const GCC_ConferencePriority & other = (const GCC_ConferencePriority &)obj;
  1738.  
  1739.   Comparison result;
  1740.  
  1741.   if ((result = m_priority.Compare(other.m_priority)) != EqualTo)
  1742.     return result;
  1743.   if ((result = m_scheme.Compare(other.m_scheme)) != EqualTo)
  1744.     return result;
  1745.  
  1746.   return PASN_Sequence::Compare(other);
  1747. }
  1748.  
  1749.  
  1750. PINDEX GCC_ConferencePriority::GetDataLength() const
  1751. {
  1752.   PINDEX length = 0;
  1753.   length += m_priority.GetObjectLength();
  1754.   length += m_scheme.GetObjectLength();
  1755.   return length;
  1756. }
  1757.  
  1758.  
  1759. BOOL GCC_ConferencePriority::Decode(PASN_Stream & strm)
  1760. {
  1761.   if (!PreambleDecode(strm))
  1762.     return FALSE;
  1763.  
  1764.   if (!m_priority.Decode(strm))
  1765.     return FALSE;
  1766.   if (!m_scheme.Decode(strm))
  1767.     return FALSE;
  1768.  
  1769.   return UnknownExtensionsDecode(strm);
  1770. }
  1771.  
  1772.  
  1773. void GCC_ConferencePriority::Encode(PASN_Stream & strm) const
  1774. {
  1775.   PreambleEncode(strm);
  1776.  
  1777.   m_priority.Encode(strm);
  1778.   m_scheme.Encode(strm);
  1779.  
  1780.   UnknownExtensionsEncode(strm);
  1781. }
  1782.  
  1783.  
  1784. PObject * GCC_ConferencePriority::Clone() const
  1785. {
  1786. #ifndef PASN_LEANANDMEAN
  1787.   PAssert(IsClass(GCC_ConferencePriority::Class()), PInvalidCast);
  1788. #endif
  1789.   return new GCC_ConferencePriority(*this);
  1790. }
  1791.  
  1792.  
  1793. //
  1794. // NetworkAddress
  1795. //
  1796.  
  1797. GCC_NetworkAddress::GCC_NetworkAddress(unsigned tag, PASN_Object::TagClass tagClass)
  1798.   : PASN_Array(tag, tagClass)
  1799. {
  1800.   SetConstraints(PASN_Object::FixedConstraint, 1, 64);
  1801. }
  1802.  
  1803.  
  1804. PASN_Object * GCC_NetworkAddress::CreateObject() const
  1805. {
  1806.   return new GCC_NetworkAddress_subtype;
  1807. }
  1808.  
  1809.  
  1810. GCC_NetworkAddress_subtype & GCC_NetworkAddress::operator[](PINDEX i) const
  1811. {
  1812.   return (GCC_NetworkAddress_subtype &)array[i];
  1813. }
  1814.  
  1815.  
  1816. PObject * GCC_NetworkAddress::Clone() const
  1817. {
  1818. #ifndef PASN_LEANANDMEAN
  1819.   PAssert(IsClass(GCC_NetworkAddress::Class()), PInvalidCast);
  1820. #endif
  1821.   return new GCC_NetworkAddress(*this);
  1822. }
  1823.  
  1824.  
  1825. //
  1826. // NodeType
  1827. //
  1828.  
  1829. GCC_NodeType::GCC_NodeType(unsigned tag, PASN_Object::TagClass tagClass)
  1830.   : PASN_Enumeration(tag, tagClass, 2, TRUE
  1831. #ifndef PASN_NOPRINTON
  1832.       , "terminal "
  1833.         "multiportTerminal "
  1834.         "mcu "
  1835. #endif
  1836.     )
  1837. {
  1838. }
  1839.  
  1840.  
  1841. GCC_NodeType & GCC_NodeType::operator=(unsigned v)
  1842. {
  1843.   SetValue(v);
  1844.   return *this;
  1845. }
  1846.  
  1847.  
  1848. PObject * GCC_NodeType::Clone() const
  1849. {
  1850. #ifndef PASN_LEANANDMEAN
  1851.   PAssert(IsClass(GCC_NodeType::Class()), PInvalidCast);
  1852. #endif
  1853.   return new GCC_NodeType(*this);
  1854. }
  1855.  
  1856.  
  1857. //
  1858. // NodeProperties
  1859. //
  1860.  
  1861. GCC_NodeProperties::GCC_NodeProperties(unsigned tag, PASN_Object::TagClass tagClass)
  1862.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  1863. {
  1864. }
  1865.  
  1866.  
  1867. #ifndef PASN_NOPRINTON
  1868. void GCC_NodeProperties::PrintOn(ostream & strm) const
  1869. {
  1870.   int indent = strm.precision() + 2;
  1871.   strm << "{\n";
  1872.   strm << setw(indent+19) << "managementDevice = " << setprecision(indent) << m_managementDevice << '\n';
  1873.   strm << setw(indent+19) << "peripheralDevice = " << setprecision(indent) << m_peripheralDevice << '\n';
  1874.   strm << setw(indent-1) << "}";
  1875. }
  1876. #endif
  1877.  
  1878.  
  1879. PObject::Comparison GCC_NodeProperties::Compare(const PObject & obj) const
  1880. {
  1881. #ifndef PASN_LEANANDMEAN
  1882.   PAssert(IsDescendant(GCC_NodeProperties::Class()), PInvalidCast);
  1883. #endif
  1884.   const GCC_NodeProperties & other = (const GCC_NodeProperties &)obj;
  1885.  
  1886.   Comparison result;
  1887.  
  1888.   if ((result = m_managementDevice.Compare(other.m_managementDevice)) != EqualTo)
  1889.     return result;
  1890.   if ((result = m_peripheralDevice.Compare(other.m_peripheralDevice)) != EqualTo)
  1891.     return result;
  1892.  
  1893.   return PASN_Sequence::Compare(other);
  1894. }
  1895.  
  1896.  
  1897. PINDEX GCC_NodeProperties::GetDataLength() const
  1898. {
  1899.   PINDEX length = 0;
  1900.   length += m_managementDevice.GetObjectLength();
  1901.   length += m_peripheralDevice.GetObjectLength();
  1902.   return length;
  1903. }
  1904.  
  1905.  
  1906. BOOL GCC_NodeProperties::Decode(PASN_Stream & strm)
  1907. {
  1908.   if (!PreambleDecode(strm))
  1909.     return FALSE;
  1910.  
  1911.   if (!m_managementDevice.Decode(strm))
  1912.     return FALSE;
  1913.   if (!m_peripheralDevice.Decode(strm))
  1914.     return FALSE;
  1915.  
  1916.   return UnknownExtensionsDecode(strm);
  1917. }
  1918.  
  1919.  
  1920. void GCC_NodeProperties::Encode(PASN_Stream & strm) const
  1921. {
  1922.   PreambleEncode(strm);
  1923.  
  1924.   m_managementDevice.Encode(strm);
  1925.   m_peripheralDevice.Encode(strm);
  1926.  
  1927.   UnknownExtensionsEncode(strm);
  1928. }
  1929.  
  1930.  
  1931. PObject * GCC_NodeProperties::Clone() const
  1932. {
  1933. #ifndef PASN_LEANANDMEAN
  1934.   PAssert(IsClass(GCC_NodeProperties::Class()), PInvalidCast);
  1935. #endif
  1936.   return new GCC_NodeProperties(*this);
  1937. }
  1938.  
  1939.  
  1940. //
  1941. // AsymmetryIndicator
  1942. //
  1943.  
  1944. GCC_AsymmetryIndicator::GCC_AsymmetryIndicator(unsigned tag, PASN_Object::TagClass tagClass)
  1945.   : PASN_Choice(tag, tagClass, 3, FALSE
  1946. #ifndef PASN_NOPRINTON
  1947.       , "callingNode "
  1948.         "calledNode "
  1949.         "unknown "
  1950. #endif
  1951.     )
  1952. {
  1953. }
  1954.  
  1955.  
  1956. BOOL GCC_AsymmetryIndicator::CreateObject()
  1957. {
  1958.   switch (tag) {
  1959.     case e_callingNode :
  1960.     case e_calledNode :
  1961.       choice = new PASN_Null();
  1962.       return TRUE;
  1963.     case e_unknown :
  1964.       choice = new PASN_Integer();
  1965.       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
  1966.       return TRUE;
  1967.   }
  1968.  
  1969.   choice = NULL;
  1970.   return FALSE;
  1971. }
  1972.  
  1973.  
  1974. PObject * GCC_AsymmetryIndicator::Clone() const
  1975. {
  1976. #ifndef PASN_LEANANDMEAN
  1977.   PAssert(IsClass(GCC_AsymmetryIndicator::Class()), PInvalidCast);
  1978. #endif
  1979.   return new GCC_AsymmetryIndicator(*this);
  1980. }
  1981.  
  1982.  
  1983. //
  1984. // AlternativeNodeID
  1985. //
  1986.  
  1987. GCC_AlternativeNodeID::GCC_AlternativeNodeID(unsigned tag, PASN_Object::TagClass tagClass)
  1988.   : PASN_Choice(tag, tagClass, 1, TRUE
  1989. #ifndef PASN_NOPRINTON
  1990.       , "h243NodeID "
  1991. #endif
  1992.     )
  1993. {
  1994. }
  1995.  
  1996.  
  1997. BOOL GCC_AlternativeNodeID::CreateObject()
  1998. {
  1999.   switch (tag) {
  2000.     case e_h243NodeID :
  2001.       choice = new PASN_OctetString();
  2002.       choice->SetConstraints(PASN_Object::FixedConstraint, 2);
  2003.       return TRUE;
  2004.   }
  2005.  
  2006.   choice = NULL;
  2007.   return FALSE;
  2008. }
  2009.  
  2010.  
  2011. PObject * GCC_AlternativeNodeID::Clone() const
  2012. {
  2013. #ifndef PASN_LEANANDMEAN
  2014.   PAssert(IsClass(GCC_AlternativeNodeID::Class()), PInvalidCast);
  2015. #endif
  2016.   return new GCC_AlternativeNodeID(*this);
  2017. }
  2018.  
  2019.  
  2020. //
  2021. // ConferenceDescriptor
  2022. //
  2023.  
  2024. GCC_ConferenceDescriptor::GCC_ConferenceDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
  2025.   : PASN_Sequence(tag, tagClass, 3, TRUE, 1)
  2026. {
  2027.   IncludeOptionalField(e_defaultConferenceFlag);
  2028. }
  2029.  
  2030.  
  2031. #ifndef PASN_NOPRINTON
  2032. void GCC_ConferenceDescriptor::PrintOn(ostream & strm) const
  2033. {
  2034.   int indent = strm.precision() + 2;
  2035.   strm << "{\n";
  2036.   strm << setw(indent+17) << "conferenceName = " << setprecision(indent) << m_conferenceName << '\n';
  2037.   if (HasOptionalField(e_conferenceNameModifier))
  2038.     strm << setw(indent+25) << "conferenceNameModifier = " << setprecision(indent) << m_conferenceNameModifier << '\n';
  2039.   if (HasOptionalField(e_conferenceDescription))
  2040.     strm << setw(indent+24) << "conferenceDescription = " << setprecision(indent) << m_conferenceDescription << '\n';
  2041.   strm << setw(indent+19) << "lockedConference = " << setprecision(indent) << m_lockedConference << '\n';
  2042.   strm << setw(indent+29) << "passwordInTheClearRequired = " << setprecision(indent) << m_passwordInTheClearRequired << '\n';
  2043.   if (HasOptionalField(e_networkAddress))
  2044.     strm << setw(indent+17) << "networkAddress = " << setprecision(indent) << m_networkAddress << '\n';
  2045.   if (HasOptionalField(e_defaultConferenceFlag))
  2046.     strm << setw(indent+24) << "defaultConferenceFlag = " << setprecision(indent) << m_defaultConferenceFlag << '\n';
  2047.   strm << setw(indent-1) << "}";
  2048. }
  2049. #endif
  2050.  
  2051.  
  2052. PObject::Comparison GCC_ConferenceDescriptor::Compare(const PObject & obj) const
  2053. {
  2054. #ifndef PASN_LEANANDMEAN
  2055.   PAssert(IsDescendant(GCC_ConferenceDescriptor::Class()), PInvalidCast);
  2056. #endif
  2057.   const GCC_ConferenceDescriptor & other = (const GCC_ConferenceDescriptor &)obj;
  2058.  
  2059.   Comparison result;
  2060.  
  2061.   if ((result = m_conferenceName.Compare(other.m_conferenceName)) != EqualTo)
  2062.     return result;
  2063.   if ((result = m_conferenceNameModifier.Compare(other.m_conferenceNameModifier)) != EqualTo)
  2064.     return result;
  2065.   if ((result = m_conferenceDescription.Compare(other.m_conferenceDescription)) != EqualTo)
  2066.     return result;
  2067.   if ((result = m_lockedConference.Compare(other.m_lockedConference)) != EqualTo)
  2068.     return result;
  2069.   if ((result = m_passwordInTheClearRequired.Compare(other.m_passwordInTheClearRequired)) != EqualTo)
  2070.     return result;
  2071.   if ((result = m_networkAddress.Compare(other.m_networkAddress)) != EqualTo)
  2072.     return result;
  2073.  
  2074.   return PASN_Sequence::Compare(other);
  2075. }
  2076.  
  2077.  
  2078. PINDEX GCC_ConferenceDescriptor::GetDataLength() const
  2079. {
  2080.   PINDEX length = 0;
  2081.   length += m_conferenceName.GetObjectLength();
  2082.   if (HasOptionalField(e_conferenceNameModifier))
  2083.     length += m_conferenceNameModifier.GetObjectLength();
  2084.   if (HasOptionalField(e_conferenceDescription))
  2085.     length += m_conferenceDescription.GetObjectLength();
  2086.   length += m_lockedConference.GetObjectLength();
  2087.   length += m_passwordInTheClearRequired.GetObjectLength();
  2088.   if (HasOptionalField(e_networkAddress))
  2089.     length += m_networkAddress.GetObjectLength();
  2090.   return length;
  2091. }
  2092.  
  2093.  
  2094. BOOL GCC_ConferenceDescriptor::Decode(PASN_Stream & strm)
  2095. {
  2096.   if (!PreambleDecode(strm))
  2097.     return FALSE;
  2098.  
  2099.   if (!m_conferenceName.Decode(strm))
  2100.     return FALSE;
  2101.   if (HasOptionalField(e_conferenceNameModifier) && !m_conferenceNameModifier.Decode(strm))
  2102.     return FALSE;
  2103.   if (HasOptionalField(e_conferenceDescription) && !m_conferenceDescription.Decode(strm))
  2104.     return FALSE;
  2105.   if (!m_lockedConference.Decode(strm))
  2106.     return FALSE;
  2107.   if (!m_passwordInTheClearRequired.Decode(strm))
  2108.     return FALSE;
  2109.   if (HasOptionalField(e_networkAddress) && !m_networkAddress.Decode(strm))
  2110.     return FALSE;
  2111.   if (!KnownExtensionDecode(strm, e_defaultConferenceFlag, m_defaultConferenceFlag))
  2112.     return FALSE;
  2113.  
  2114.   return UnknownExtensionsDecode(strm);
  2115. }
  2116.  
  2117.  
  2118. void GCC_ConferenceDescriptor::Encode(PASN_Stream & strm) const
  2119. {
  2120.   PreambleEncode(strm);
  2121.  
  2122.   m_conferenceName.Encode(strm);
  2123.   if (HasOptionalField(e_conferenceNameModifier))
  2124.     m_conferenceNameModifier.Encode(strm);
  2125.   if (HasOptionalField(e_conferenceDescription))
  2126.     m_conferenceDescription.Encode(strm);
  2127.   m_lockedConference.Encode(strm);
  2128.   m_passwordInTheClearRequired.Encode(strm);
  2129.   if (HasOptionalField(e_networkAddress))
  2130.     m_networkAddress.Encode(strm);
  2131.   KnownExtensionEncode(strm, e_defaultConferenceFlag, m_defaultConferenceFlag);
  2132.  
  2133.   UnknownExtensionsEncode(strm);
  2134. }
  2135.  
  2136.  
  2137. PObject * GCC_ConferenceDescriptor::Clone() const
  2138. {
  2139. #ifndef PASN_LEANANDMEAN
  2140.   PAssert(IsClass(GCC_ConferenceDescriptor::Class()), PInvalidCast);
  2141. #endif
  2142.   return new GCC_ConferenceDescriptor(*this);
  2143. }
  2144.  
  2145.  
  2146. //
  2147. // SessionKey
  2148. //
  2149.  
  2150. GCC_SessionKey::GCC_SessionKey(unsigned tag, PASN_Object::TagClass tagClass)
  2151.   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
  2152. {
  2153. }
  2154.  
  2155.  
  2156. #ifndef PASN_NOPRINTON
  2157. void GCC_SessionKey::PrintOn(ostream & strm) const
  2158. {
  2159.   int indent = strm.precision() + 2;
  2160.   strm << "{\n";
  2161.   strm << setw(indent+25) << "applicationProtocolKey = " << setprecision(indent) << m_applicationProtocolKey << '\n';
  2162.   if (HasOptionalField(e_sessionID))
  2163.     strm << setw(indent+12) << "sessionID = " << setprecision(indent) << m_sessionID << '\n';
  2164.   strm << setw(indent-1) << "}";
  2165. }
  2166. #endif
  2167.  
  2168.  
  2169. PObject::Comparison GCC_SessionKey::Compare(const PObject & obj) const
  2170. {
  2171. #ifndef PASN_LEANANDMEAN
  2172.   PAssert(IsDescendant(GCC_SessionKey::Class()), PInvalidCast);
  2173. #endif
  2174.   const GCC_SessionKey & other = (const GCC_SessionKey &)obj;
  2175.  
  2176.   Comparison result;
  2177.  
  2178.   if ((result = m_applicationProtocolKey.Compare(other.m_applicationProtocolKey)) != EqualTo)
  2179.     return result;
  2180.   if ((result = m_sessionID.Compare(other.m_sessionID)) != EqualTo)
  2181.     return result;
  2182.  
  2183.   return PASN_Sequence::Compare(other);
  2184. }
  2185.  
  2186.  
  2187. PINDEX GCC_SessionKey::GetDataLength() const
  2188. {
  2189.   PINDEX length = 0;
  2190.   length += m_applicationProtocolKey.GetObjectLength();
  2191.   if (HasOptionalField(e_sessionID))
  2192.     length += m_sessionID.GetObjectLength();
  2193.   return length;
  2194. }
  2195.  
  2196.  
  2197. BOOL GCC_SessionKey::Decode(PASN_Stream & strm)
  2198. {
  2199.   if (!PreambleDecode(strm))
  2200.     return FALSE;
  2201.  
  2202.   if (!m_applicationProtocolKey.Decode(strm))
  2203.     return FALSE;
  2204.   if (HasOptionalField(e_sessionID) && !m_sessionID.Decode(strm))
  2205.     return FALSE;
  2206.  
  2207.   return UnknownExtensionsDecode(strm);
  2208. }
  2209.  
  2210.  
  2211. void GCC_SessionKey::Encode(PASN_Stream & strm) const
  2212. {
  2213.   PreambleEncode(strm);
  2214.  
  2215.   m_applicationProtocolKey.Encode(strm);
  2216.   if (HasOptionalField(e_sessionID))
  2217.     m_sessionID.Encode(strm);
  2218.  
  2219.   UnknownExtensionsEncode(strm);
  2220. }
  2221.  
  2222.  
  2223. PObject * GCC_SessionKey::Clone() const
  2224. {
  2225. #ifndef PASN_LEANANDMEAN
  2226.   PAssert(IsClass(GCC_SessionKey::Class()), PInvalidCast);
  2227. #endif
  2228.   return new GCC_SessionKey(*this);
  2229. }
  2230.  
  2231.  
  2232. //
  2233. // ChannelType
  2234. //
  2235.  
  2236. GCC_ChannelType::GCC_ChannelType(unsigned tag, PASN_Object::TagClass tagClass)
  2237.   : PASN_Enumeration(tag, tagClass, 3, FALSE
  2238. #ifndef PASN_NOPRINTON
  2239.       , "static "
  2240.         "dynamicMulticast "
  2241.         "dynamicPrivate "
  2242.         "dynamicUserId "
  2243. #endif
  2244.     )
  2245. {
  2246. }
  2247.  
  2248.  
  2249. GCC_ChannelType & GCC_ChannelType::operator=(unsigned v)
  2250. {
  2251.   SetValue(v);
  2252.   return *this;
  2253. }
  2254.  
  2255.  
  2256. PObject * GCC_ChannelType::Clone() const
  2257. {
  2258. #ifndef PASN_LEANANDMEAN
  2259.   PAssert(IsClass(GCC_ChannelType::Class()), PInvalidCast);
  2260. #endif
  2261.   return new GCC_ChannelType(*this);
  2262. }
  2263.  
  2264.  
  2265. //
  2266. // CapabilityID
  2267. //
  2268.  
  2269. GCC_CapabilityID::GCC_CapabilityID(unsigned tag, PASN_Object::TagClass tagClass)
  2270.   : PASN_Choice(tag, tagClass, 2, FALSE
  2271. #ifndef PASN_NOPRINTON
  2272.       , "standard "
  2273.         "nonStandard "
  2274. #endif
  2275.     )
  2276. {
  2277. }
  2278.  
  2279.  
  2280. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  2281. GCC_CapabilityID::operator GCC_Key &() const
  2282. #else
  2283. GCC_CapabilityID::operator GCC_Key &()
  2284. {
  2285. #ifndef PASN_LEANANDMEAN
  2286.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_Key::Class()), PInvalidCast);
  2287. #endif
  2288.   return *(GCC_Key *)choice;
  2289. }
  2290.  
  2291.  
  2292. GCC_CapabilityID::operator const GCC_Key &() const
  2293. #endif
  2294. {
  2295. #ifndef PASN_LEANANDMEAN
  2296.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_Key::Class()), PInvalidCast);
  2297. #endif
  2298.   return *(GCC_Key *)choice;
  2299. }
  2300.  
  2301.  
  2302. BOOL GCC_CapabilityID::CreateObject()
  2303. {
  2304.   switch (tag) {
  2305.     case e_standard :
  2306.       choice = new PASN_Integer();
  2307.       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  2308.       return TRUE;
  2309.     case e_nonStandard :
  2310.       choice = new GCC_Key();
  2311.       return TRUE;
  2312.   }
  2313.  
  2314.   choice = NULL;
  2315.   return FALSE;
  2316. }
  2317.  
  2318.  
  2319. PObject * GCC_CapabilityID::Clone() const
  2320. {
  2321. #ifndef PASN_LEANANDMEAN
  2322.   PAssert(IsClass(GCC_CapabilityID::Class()), PInvalidCast);
  2323. #endif
  2324.   return new GCC_CapabilityID(*this);
  2325. }
  2326.  
  2327.  
  2328. //
  2329. // CapabilityClass
  2330. //
  2331.  
  2332. GCC_CapabilityClass::GCC_CapabilityClass(unsigned tag, PASN_Object::TagClass tagClass)
  2333.   : PASN_Choice(tag, tagClass, 3, TRUE
  2334. #ifndef PASN_NOPRINTON
  2335.       , "logical "
  2336.         "unsignedMin "
  2337.         "unsignedMax "
  2338. #endif
  2339.     )
  2340. {
  2341. }
  2342.  
  2343.  
  2344. BOOL GCC_CapabilityClass::CreateObject()
  2345. {
  2346.   switch (tag) {
  2347.     case e_logical :
  2348.       choice = new PASN_Null();
  2349.       return TRUE;
  2350.     case e_unsignedMin :
  2351.       choice = new PASN_Integer();
  2352.       choice->SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  2353.       return TRUE;
  2354.     case e_unsignedMax :
  2355.       choice = new PASN_Integer();
  2356.       choice->SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
  2357.       return TRUE;
  2358.   }
  2359.  
  2360.   choice = NULL;
  2361.   return FALSE;
  2362. }
  2363.  
  2364.  
  2365. PObject * GCC_CapabilityClass::Clone() const
  2366. {
  2367. #ifndef PASN_LEANANDMEAN
  2368.   PAssert(IsClass(GCC_CapabilityClass::Class()), PInvalidCast);
  2369. #endif
  2370.   return new GCC_CapabilityClass(*this);
  2371. }
  2372.  
  2373.  
  2374. //
  2375. // EntityID
  2376. //
  2377.  
  2378. GCC_EntityID::GCC_EntityID(unsigned tag, PASN_Object::TagClass tagClass)
  2379.   : PASN_Integer(tag, tagClass)
  2380. {
  2381.   SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  2382. }
  2383.  
  2384.  
  2385. GCC_EntityID & GCC_EntityID::operator=(int v)
  2386. {
  2387.   SetValue(v);
  2388.   return *this;
  2389. }
  2390.  
  2391.  
  2392. GCC_EntityID & GCC_EntityID::operator=(unsigned v)
  2393. {
  2394.   SetValue(v);
  2395.   return *this;
  2396. }
  2397.  
  2398.  
  2399. PObject * GCC_EntityID::Clone() const
  2400. {
  2401. #ifndef PASN_LEANANDMEAN
  2402.   PAssert(IsClass(GCC_EntityID::Class()), PInvalidCast);
  2403. #endif
  2404.   return new GCC_EntityID(*this);
  2405. }
  2406.  
  2407.  
  2408. //
  2409. // RegistryKey
  2410. //
  2411.  
  2412. GCC_RegistryKey::GCC_RegistryKey(unsigned tag, PASN_Object::TagClass tagClass)
  2413.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  2414. {
  2415.   m_resourceID.SetConstraints(PASN_Object::FixedConstraint, 0, 64);
  2416. }
  2417.  
  2418.  
  2419. #ifndef PASN_NOPRINTON
  2420. void GCC_RegistryKey::PrintOn(ostream & strm) const
  2421. {
  2422.   int indent = strm.precision() + 2;
  2423.   strm << "{\n";
  2424.   strm << setw(indent+13) << "sessionKey = " << setprecision(indent) << m_sessionKey << '\n';
  2425.   strm << setw(indent+13) << "resourceID = " << setprecision(indent) << m_resourceID << '\n';
  2426.   strm << setw(indent-1) << "}";
  2427. }
  2428. #endif
  2429.  
  2430.  
  2431. PObject::Comparison GCC_RegistryKey::Compare(const PObject & obj) const
  2432. {
  2433. #ifndef PASN_LEANANDMEAN
  2434.   PAssert(IsDescendant(GCC_RegistryKey::Class()), PInvalidCast);
  2435. #endif
  2436.   const GCC_RegistryKey & other = (const GCC_RegistryKey &)obj;
  2437.  
  2438.   Comparison result;
  2439.  
  2440.   if ((result = m_sessionKey.Compare(other.m_sessionKey)) != EqualTo)
  2441.     return result;
  2442.   if ((result = m_resourceID.Compare(other.m_resourceID)) != EqualTo)
  2443.     return result;
  2444.  
  2445.   return PASN_Sequence::Compare(other);
  2446. }
  2447.  
  2448.  
  2449. PINDEX GCC_RegistryKey::GetDataLength() const
  2450. {
  2451.   PINDEX length = 0;
  2452.   length += m_sessionKey.GetObjectLength();
  2453.   length += m_resourceID.GetObjectLength();
  2454.   return length;
  2455. }
  2456.  
  2457.  
  2458. BOOL GCC_RegistryKey::Decode(PASN_Stream & strm)
  2459. {
  2460.   if (!PreambleDecode(strm))
  2461.     return FALSE;
  2462.  
  2463.   if (!m_sessionKey.Decode(strm))
  2464.     return FALSE;
  2465.   if (!m_resourceID.Decode(strm))
  2466.     return FALSE;
  2467.  
  2468.   return UnknownExtensionsDecode(strm);
  2469. }
  2470.  
  2471.  
  2472. void GCC_RegistryKey::Encode(PASN_Stream & strm) const
  2473. {
  2474.   PreambleEncode(strm);
  2475.  
  2476.   m_sessionKey.Encode(strm);
  2477.   m_resourceID.Encode(strm);
  2478.  
  2479.   UnknownExtensionsEncode(strm);
  2480. }
  2481.  
  2482.  
  2483. PObject * GCC_RegistryKey::Clone() const
  2484. {
  2485. #ifndef PASN_LEANANDMEAN
  2486.   PAssert(IsClass(GCC_RegistryKey::Class()), PInvalidCast);
  2487. #endif
  2488.   return new GCC_RegistryKey(*this);
  2489. }
  2490.  
  2491.  
  2492. //
  2493. // RegistryItem
  2494. //
  2495.  
  2496. GCC_RegistryItem::GCC_RegistryItem(unsigned tag, PASN_Object::TagClass tagClass)
  2497.   : PASN_Choice(tag, tagClass, 4, TRUE
  2498. #ifndef PASN_NOPRINTON
  2499.       , "channelID "
  2500.         "tokenID "
  2501.         "parameter "
  2502.         "vacant "
  2503. #endif
  2504.     )
  2505. {
  2506. }
  2507.  
  2508.  
  2509. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  2510. GCC_RegistryItem::operator GCC_DynamicChannelID &() const
  2511. #else
  2512. GCC_RegistryItem::operator GCC_DynamicChannelID &()
  2513. {
  2514. #ifndef PASN_LEANANDMEAN
  2515.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_DynamicChannelID::Class()), PInvalidCast);
  2516. #endif
  2517.   return *(GCC_DynamicChannelID *)choice;
  2518. }
  2519.  
  2520.  
  2521. GCC_RegistryItem::operator const GCC_DynamicChannelID &() const
  2522. #endif
  2523. {
  2524. #ifndef PASN_LEANANDMEAN
  2525.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_DynamicChannelID::Class()), PInvalidCast);
  2526. #endif
  2527.   return *(GCC_DynamicChannelID *)choice;
  2528. }
  2529.  
  2530.  
  2531. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  2532. GCC_RegistryItem::operator GCC_DynamicTokenID &() const
  2533. #else
  2534. GCC_RegistryItem::operator GCC_DynamicTokenID &()
  2535. {
  2536. #ifndef PASN_LEANANDMEAN
  2537.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_DynamicTokenID::Class()), PInvalidCast);
  2538. #endif
  2539.   return *(GCC_DynamicTokenID *)choice;
  2540. }
  2541.  
  2542.  
  2543. GCC_RegistryItem::operator const GCC_DynamicTokenID &() const
  2544. #endif
  2545. {
  2546. #ifndef PASN_LEANANDMEAN
  2547.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_DynamicTokenID::Class()), PInvalidCast);
  2548. #endif
  2549.   return *(GCC_DynamicTokenID *)choice;
  2550. }
  2551.  
  2552.  
  2553. BOOL GCC_RegistryItem::CreateObject()
  2554. {
  2555.   switch (tag) {
  2556.     case e_channelID :
  2557.       choice = new GCC_DynamicChannelID();
  2558.       return TRUE;
  2559.     case e_tokenID :
  2560.       choice = new GCC_DynamicTokenID();
  2561.       return TRUE;
  2562.     case e_parameter :
  2563.       choice = new PASN_OctetString();
  2564.       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 64);
  2565.       return TRUE;
  2566.     case e_vacant :
  2567.       choice = new PASN_Null();
  2568.       return TRUE;
  2569.   }
  2570.  
  2571.   choice = NULL;
  2572.   return FALSE;
  2573. }
  2574.  
  2575.  
  2576. PObject * GCC_RegistryItem::Clone() const
  2577. {
  2578. #ifndef PASN_LEANANDMEAN
  2579.   PAssert(IsClass(GCC_RegistryItem::Class()), PInvalidCast);
  2580. #endif
  2581.   return new GCC_RegistryItem(*this);
  2582. }
  2583.  
  2584.  
  2585. //
  2586. // RegistryEntryOwner
  2587. //
  2588.  
  2589. GCC_RegistryEntryOwner::GCC_RegistryEntryOwner(unsigned tag, PASN_Object::TagClass tagClass)
  2590.   : PASN_Choice(tag, tagClass, 2, FALSE
  2591. #ifndef PASN_NOPRINTON
  2592.       , "owned "
  2593.         "notOwned "
  2594. #endif
  2595.     )
  2596. {
  2597. }
  2598.  
  2599.  
  2600. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  2601. GCC_RegistryEntryOwner::operator GCC_RegistryEntryOwner_owned &() const
  2602. #else
  2603. GCC_RegistryEntryOwner::operator GCC_RegistryEntryOwner_owned &()
  2604. {
  2605. #ifndef PASN_LEANANDMEAN
  2606.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryEntryOwner_owned::Class()), PInvalidCast);
  2607. #endif
  2608.   return *(GCC_RegistryEntryOwner_owned *)choice;
  2609. }
  2610.  
  2611.  
  2612. GCC_RegistryEntryOwner::operator const GCC_RegistryEntryOwner_owned &() const
  2613. #endif
  2614. {
  2615. #ifndef PASN_LEANANDMEAN
  2616.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryEntryOwner_owned::Class()), PInvalidCast);
  2617. #endif
  2618.   return *(GCC_RegistryEntryOwner_owned *)choice;
  2619. }
  2620.  
  2621.  
  2622. BOOL GCC_RegistryEntryOwner::CreateObject()
  2623. {
  2624.   switch (tag) {
  2625.     case e_owned :
  2626.       choice = new GCC_RegistryEntryOwner_owned();
  2627.       return TRUE;
  2628.     case e_notOwned :
  2629.       choice = new PASN_Null();
  2630.       return TRUE;
  2631.   }
  2632.  
  2633.   choice = NULL;
  2634.   return FALSE;
  2635. }
  2636.  
  2637.  
  2638. PObject * GCC_RegistryEntryOwner::Clone() const
  2639. {
  2640. #ifndef PASN_LEANANDMEAN
  2641.   PAssert(IsClass(GCC_RegistryEntryOwner::Class()), PInvalidCast);
  2642. #endif
  2643.   return new GCC_RegistryEntryOwner(*this);
  2644. }
  2645.  
  2646.  
  2647. //
  2648. // RegistryModificationRights
  2649. //
  2650.  
  2651. GCC_RegistryModificationRights::GCC_RegistryModificationRights(unsigned tag, PASN_Object::TagClass tagClass)
  2652.   : PASN_Enumeration(tag, tagClass, 2, FALSE
  2653. #ifndef PASN_NOPRINTON
  2654.       , "owner "
  2655.         "session "
  2656.         "public "
  2657. #endif
  2658.     )
  2659. {
  2660. }
  2661.  
  2662.  
  2663. GCC_RegistryModificationRights & GCC_RegistryModificationRights::operator=(unsigned v)
  2664. {
  2665.   SetValue(v);
  2666.   return *this;
  2667. }
  2668.  
  2669.  
  2670. PObject * GCC_RegistryModificationRights::Clone() const
  2671. {
  2672. #ifndef PASN_LEANANDMEAN
  2673.   PAssert(IsClass(GCC_RegistryModificationRights::Class()), PInvalidCast);
  2674. #endif
  2675.   return new GCC_RegistryModificationRights(*this);
  2676. }
  2677.  
  2678.  
  2679. //
  2680. // UserIDIndication
  2681. //
  2682.  
  2683. GCC_UserIDIndication::GCC_UserIDIndication(unsigned tag, PASN_Object::TagClass tagClass)
  2684.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  2685. {
  2686. }
  2687.  
  2688.  
  2689. #ifndef PASN_NOPRINTON
  2690. void GCC_UserIDIndication::PrintOn(ostream & strm) const
  2691. {
  2692.   int indent = strm.precision() + 2;
  2693.   strm << "{\n";
  2694.   strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  2695.   strm << setw(indent-1) << "}";
  2696. }
  2697. #endif
  2698.  
  2699.  
  2700. PObject::Comparison GCC_UserIDIndication::Compare(const PObject & obj) const
  2701. {
  2702. #ifndef PASN_LEANANDMEAN
  2703.   PAssert(IsDescendant(GCC_UserIDIndication::Class()), PInvalidCast);
  2704. #endif
  2705.   const GCC_UserIDIndication & other = (const GCC_UserIDIndication &)obj;
  2706.  
  2707.   Comparison result;
  2708.  
  2709.   if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
  2710.     return result;
  2711.  
  2712.   return PASN_Sequence::Compare(other);
  2713. }
  2714.  
  2715.  
  2716. PINDEX GCC_UserIDIndication::GetDataLength() const
  2717. {
  2718.   PINDEX length = 0;
  2719.   length += m_tag.GetObjectLength();
  2720.   return length;
  2721. }
  2722.  
  2723.  
  2724. BOOL GCC_UserIDIndication::Decode(PASN_Stream & strm)
  2725. {
  2726.   if (!PreambleDecode(strm))
  2727.     return FALSE;
  2728.  
  2729.   if (!m_tag.Decode(strm))
  2730.     return FALSE;
  2731.  
  2732.   return UnknownExtensionsDecode(strm);
  2733. }
  2734.  
  2735.  
  2736. void GCC_UserIDIndication::Encode(PASN_Stream & strm) const
  2737. {
  2738.   PreambleEncode(strm);
  2739.  
  2740.   m_tag.Encode(strm);
  2741.  
  2742.   UnknownExtensionsEncode(strm);
  2743. }
  2744.  
  2745.  
  2746. PObject * GCC_UserIDIndication::Clone() const
  2747. {
  2748. #ifndef PASN_LEANANDMEAN
  2749.   PAssert(IsClass(GCC_UserIDIndication::Class()), PInvalidCast);
  2750. #endif
  2751.   return new GCC_UserIDIndication(*this);
  2752. }
  2753.  
  2754.  
  2755. //
  2756. // ConferenceQueryRequest
  2757. //
  2758.  
  2759. GCC_ConferenceQueryRequest::GCC_ConferenceQueryRequest(unsigned tag, PASN_Object::TagClass tagClass)
  2760.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  2761. {
  2762. }
  2763.  
  2764.  
  2765. #ifndef PASN_NOPRINTON
  2766. void GCC_ConferenceQueryRequest::PrintOn(ostream & strm) const
  2767. {
  2768.   int indent = strm.precision() + 2;
  2769.   strm << "{\n";
  2770.   strm << setw(indent+11) << "nodeType = " << setprecision(indent) << m_nodeType << '\n';
  2771.   if (HasOptionalField(e_asymmetryIndicator))
  2772.     strm << setw(indent+21) << "asymmetryIndicator = " << setprecision(indent) << m_asymmetryIndicator << '\n';
  2773.   if (HasOptionalField(e_userData))
  2774.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  2775.   strm << setw(indent-1) << "}";
  2776. }
  2777. #endif
  2778.  
  2779.  
  2780. PObject::Comparison GCC_ConferenceQueryRequest::Compare(const PObject & obj) const
  2781. {
  2782. #ifndef PASN_LEANANDMEAN
  2783.   PAssert(IsDescendant(GCC_ConferenceQueryRequest::Class()), PInvalidCast);
  2784. #endif
  2785.   const GCC_ConferenceQueryRequest & other = (const GCC_ConferenceQueryRequest &)obj;
  2786.  
  2787.   Comparison result;
  2788.  
  2789.   if ((result = m_nodeType.Compare(other.m_nodeType)) != EqualTo)
  2790.     return result;
  2791.   if ((result = m_asymmetryIndicator.Compare(other.m_asymmetryIndicator)) != EqualTo)
  2792.     return result;
  2793.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  2794.     return result;
  2795.  
  2796.   return PASN_Sequence::Compare(other);
  2797. }
  2798.  
  2799.  
  2800. PINDEX GCC_ConferenceQueryRequest::GetDataLength() const
  2801. {
  2802.   PINDEX length = 0;
  2803.   length += m_nodeType.GetObjectLength();
  2804.   if (HasOptionalField(e_asymmetryIndicator))
  2805.     length += m_asymmetryIndicator.GetObjectLength();
  2806.   if (HasOptionalField(e_userData))
  2807.     length += m_userData.GetObjectLength();
  2808.   return length;
  2809. }
  2810.  
  2811.  
  2812. BOOL GCC_ConferenceQueryRequest::Decode(PASN_Stream & strm)
  2813. {
  2814.   if (!PreambleDecode(strm))
  2815.     return FALSE;
  2816.  
  2817.   if (!m_nodeType.Decode(strm))
  2818.     return FALSE;
  2819.   if (HasOptionalField(e_asymmetryIndicator) && !m_asymmetryIndicator.Decode(strm))
  2820.     return FALSE;
  2821.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  2822.     return FALSE;
  2823.  
  2824.   return UnknownExtensionsDecode(strm);
  2825. }
  2826.  
  2827.  
  2828. void GCC_ConferenceQueryRequest::Encode(PASN_Stream & strm) const
  2829. {
  2830.   PreambleEncode(strm);
  2831.  
  2832.   m_nodeType.Encode(strm);
  2833.   if (HasOptionalField(e_asymmetryIndicator))
  2834.     m_asymmetryIndicator.Encode(strm);
  2835.   if (HasOptionalField(e_userData))
  2836.     m_userData.Encode(strm);
  2837.  
  2838.   UnknownExtensionsEncode(strm);
  2839. }
  2840.  
  2841.  
  2842. PObject * GCC_ConferenceQueryRequest::Clone() const
  2843. {
  2844. #ifndef PASN_LEANANDMEAN
  2845.   PAssert(IsClass(GCC_ConferenceQueryRequest::Class()), PInvalidCast);
  2846. #endif
  2847.   return new GCC_ConferenceQueryRequest(*this);
  2848. }
  2849.  
  2850.  
  2851. //
  2852. // ConferenceJoinRequest
  2853. //
  2854.  
  2855. GCC_ConferenceJoinRequest::GCC_ConferenceJoinRequest(unsigned tag, PASN_Object::TagClass tagClass)
  2856.   : PASN_Sequence(tag, tagClass, 7, TRUE, 0)
  2857. {
  2858. }
  2859.  
  2860.  
  2861. #ifndef PASN_NOPRINTON
  2862. void GCC_ConferenceJoinRequest::PrintOn(ostream & strm) const
  2863. {
  2864.   int indent = strm.precision() + 2;
  2865.   strm << "{\n";
  2866.   if (HasOptionalField(e_conferenceName))
  2867.     strm << setw(indent+17) << "conferenceName = " << setprecision(indent) << m_conferenceName << '\n';
  2868.   if (HasOptionalField(e_conferenceNameModifier))
  2869.     strm << setw(indent+25) << "conferenceNameModifier = " << setprecision(indent) << m_conferenceNameModifier << '\n';
  2870.   if (HasOptionalField(e_tag))
  2871.     strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  2872.   if (HasOptionalField(e_password))
  2873.     strm << setw(indent+11) << "password = " << setprecision(indent) << m_password << '\n';
  2874.   if (HasOptionalField(e_convenerPassword))
  2875.     strm << setw(indent+19) << "convenerPassword = " << setprecision(indent) << m_convenerPassword << '\n';
  2876.   if (HasOptionalField(e_callerIdentifier))
  2877.     strm << setw(indent+19) << "callerIdentifier = " << setprecision(indent) << m_callerIdentifier << '\n';
  2878.   if (HasOptionalField(e_userData))
  2879.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  2880.   strm << setw(indent-1) << "}";
  2881. }
  2882. #endif
  2883.  
  2884.  
  2885. PObject::Comparison GCC_ConferenceJoinRequest::Compare(const PObject & obj) const
  2886. {
  2887. #ifndef PASN_LEANANDMEAN
  2888.   PAssert(IsDescendant(GCC_ConferenceJoinRequest::Class()), PInvalidCast);
  2889. #endif
  2890.   const GCC_ConferenceJoinRequest & other = (const GCC_ConferenceJoinRequest &)obj;
  2891.  
  2892.   Comparison result;
  2893.  
  2894.   if ((result = m_conferenceName.Compare(other.m_conferenceName)) != EqualTo)
  2895.     return result;
  2896.   if ((result = m_conferenceNameModifier.Compare(other.m_conferenceNameModifier)) != EqualTo)
  2897.     return result;
  2898.   if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
  2899.     return result;
  2900.   if ((result = m_password.Compare(other.m_password)) != EqualTo)
  2901.     return result;
  2902.   if ((result = m_convenerPassword.Compare(other.m_convenerPassword)) != EqualTo)
  2903.     return result;
  2904.   if ((result = m_callerIdentifier.Compare(other.m_callerIdentifier)) != EqualTo)
  2905.     return result;
  2906.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  2907.     return result;
  2908.  
  2909.   return PASN_Sequence::Compare(other);
  2910. }
  2911.  
  2912.  
  2913. PINDEX GCC_ConferenceJoinRequest::GetDataLength() const
  2914. {
  2915.   PINDEX length = 0;
  2916.   if (HasOptionalField(e_conferenceName))
  2917.     length += m_conferenceName.GetObjectLength();
  2918.   if (HasOptionalField(e_conferenceNameModifier))
  2919.     length += m_conferenceNameModifier.GetObjectLength();
  2920.   if (HasOptionalField(e_tag))
  2921.     length += m_tag.GetObjectLength();
  2922.   if (HasOptionalField(e_password))
  2923.     length += m_password.GetObjectLength();
  2924.   if (HasOptionalField(e_convenerPassword))
  2925.     length += m_convenerPassword.GetObjectLength();
  2926.   if (HasOptionalField(e_callerIdentifier))
  2927.     length += m_callerIdentifier.GetObjectLength();
  2928.   if (HasOptionalField(e_userData))
  2929.     length += m_userData.GetObjectLength();
  2930.   return length;
  2931. }
  2932.  
  2933.  
  2934. BOOL GCC_ConferenceJoinRequest::Decode(PASN_Stream & strm)
  2935. {
  2936.   if (!PreambleDecode(strm))
  2937.     return FALSE;
  2938.  
  2939.   if (HasOptionalField(e_conferenceName) && !m_conferenceName.Decode(strm))
  2940.     return FALSE;
  2941.   if (HasOptionalField(e_conferenceNameModifier) && !m_conferenceNameModifier.Decode(strm))
  2942.     return FALSE;
  2943.   if (HasOptionalField(e_tag) && !m_tag.Decode(strm))
  2944.     return FALSE;
  2945.   if (HasOptionalField(e_password) && !m_password.Decode(strm))
  2946.     return FALSE;
  2947.   if (HasOptionalField(e_convenerPassword) && !m_convenerPassword.Decode(strm))
  2948.     return FALSE;
  2949.   if (HasOptionalField(e_callerIdentifier) && !m_callerIdentifier.Decode(strm))
  2950.     return FALSE;
  2951.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  2952.     return FALSE;
  2953.  
  2954.   return UnknownExtensionsDecode(strm);
  2955. }
  2956.  
  2957.  
  2958. void GCC_ConferenceJoinRequest::Encode(PASN_Stream & strm) const
  2959. {
  2960.   PreambleEncode(strm);
  2961.  
  2962.   if (HasOptionalField(e_conferenceName))
  2963.     m_conferenceName.Encode(strm);
  2964.   if (HasOptionalField(e_conferenceNameModifier))
  2965.     m_conferenceNameModifier.Encode(strm);
  2966.   if (HasOptionalField(e_tag))
  2967.     m_tag.Encode(strm);
  2968.   if (HasOptionalField(e_password))
  2969.     m_password.Encode(strm);
  2970.   if (HasOptionalField(e_convenerPassword))
  2971.     m_convenerPassword.Encode(strm);
  2972.   if (HasOptionalField(e_callerIdentifier))
  2973.     m_callerIdentifier.Encode(strm);
  2974.   if (HasOptionalField(e_userData))
  2975.     m_userData.Encode(strm);
  2976.  
  2977.   UnknownExtensionsEncode(strm);
  2978. }
  2979.  
  2980.  
  2981. PObject * GCC_ConferenceJoinRequest::Clone() const
  2982. {
  2983. #ifndef PASN_LEANANDMEAN
  2984.   PAssert(IsClass(GCC_ConferenceJoinRequest::Class()), PInvalidCast);
  2985. #endif
  2986.   return new GCC_ConferenceJoinRequest(*this);
  2987. }
  2988.  
  2989.  
  2990. //
  2991. // ConferenceAddRequest
  2992. //
  2993.  
  2994. GCC_ConferenceAddRequest::GCC_ConferenceAddRequest(unsigned tag, PASN_Object::TagClass tagClass)
  2995.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  2996. {
  2997. }
  2998.  
  2999.  
  3000. #ifndef PASN_NOPRINTON
  3001. void GCC_ConferenceAddRequest::PrintOn(ostream & strm) const
  3002. {
  3003.   int indent = strm.precision() + 2;
  3004.   strm << "{\n";
  3005.   strm << setw(indent+17) << "networkAddress = " << setprecision(indent) << m_networkAddress << '\n';
  3006.   strm << setw(indent+17) << "requestingNode = " << setprecision(indent) << m_requestingNode << '\n';
  3007.   strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  3008.   if (HasOptionalField(e_addingMCU))
  3009.     strm << setw(indent+12) << "addingMCU = " << setprecision(indent) << m_addingMCU << '\n';
  3010.   if (HasOptionalField(e_userData))
  3011.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  3012.   strm << setw(indent-1) << "}";
  3013. }
  3014. #endif
  3015.  
  3016.  
  3017. PObject::Comparison GCC_ConferenceAddRequest::Compare(const PObject & obj) const
  3018. {
  3019. #ifndef PASN_LEANANDMEAN
  3020.   PAssert(IsDescendant(GCC_ConferenceAddRequest::Class()), PInvalidCast);
  3021. #endif
  3022.   const GCC_ConferenceAddRequest & other = (const GCC_ConferenceAddRequest &)obj;
  3023.  
  3024.   Comparison result;
  3025.  
  3026.   if ((result = m_networkAddress.Compare(other.m_networkAddress)) != EqualTo)
  3027.     return result;
  3028.   if ((result = m_requestingNode.Compare(other.m_requestingNode)) != EqualTo)
  3029.     return result;
  3030.   if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
  3031.     return result;
  3032.   if ((result = m_addingMCU.Compare(other.m_addingMCU)) != EqualTo)
  3033.     return result;
  3034.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  3035.     return result;
  3036.  
  3037.   return PASN_Sequence::Compare(other);
  3038. }
  3039.  
  3040.  
  3041. PINDEX GCC_ConferenceAddRequest::GetDataLength() const
  3042. {
  3043.   PINDEX length = 0;
  3044.   length += m_networkAddress.GetObjectLength();
  3045.   length += m_requestingNode.GetObjectLength();
  3046.   length += m_tag.GetObjectLength();
  3047.   if (HasOptionalField(e_addingMCU))
  3048.     length += m_addingMCU.GetObjectLength();
  3049.   if (HasOptionalField(e_userData))
  3050.     length += m_userData.GetObjectLength();
  3051.   return length;
  3052. }
  3053.  
  3054.  
  3055. BOOL GCC_ConferenceAddRequest::Decode(PASN_Stream & strm)
  3056. {
  3057.   if (!PreambleDecode(strm))
  3058.     return FALSE;
  3059.  
  3060.   if (!m_networkAddress.Decode(strm))
  3061.     return FALSE;
  3062.   if (!m_requestingNode.Decode(strm))
  3063.     return FALSE;
  3064.   if (!m_tag.Decode(strm))
  3065.     return FALSE;
  3066.   if (HasOptionalField(e_addingMCU) && !m_addingMCU.Decode(strm))
  3067.     return FALSE;
  3068.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  3069.     return FALSE;
  3070.  
  3071.   return UnknownExtensionsDecode(strm);
  3072. }
  3073.  
  3074.  
  3075. void GCC_ConferenceAddRequest::Encode(PASN_Stream & strm) const
  3076. {
  3077.   PreambleEncode(strm);
  3078.  
  3079.   m_networkAddress.Encode(strm);
  3080.   m_requestingNode.Encode(strm);
  3081.   m_tag.Encode(strm);
  3082.   if (HasOptionalField(e_addingMCU))
  3083.     m_addingMCU.Encode(strm);
  3084.   if (HasOptionalField(e_userData))
  3085.     m_userData.Encode(strm);
  3086.  
  3087.   UnknownExtensionsEncode(strm);
  3088. }
  3089.  
  3090.  
  3091. PObject * GCC_ConferenceAddRequest::Clone() const
  3092. {
  3093. #ifndef PASN_LEANANDMEAN
  3094.   PAssert(IsClass(GCC_ConferenceAddRequest::Class()), PInvalidCast);
  3095. #endif
  3096.   return new GCC_ConferenceAddRequest(*this);
  3097. }
  3098.  
  3099.  
  3100. //
  3101. // ConferenceLockRequest
  3102. //
  3103.  
  3104. GCC_ConferenceLockRequest::GCC_ConferenceLockRequest(unsigned tag, PASN_Object::TagClass tagClass)
  3105.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3106. {
  3107. }
  3108.  
  3109.  
  3110. #ifndef PASN_NOPRINTON
  3111. void GCC_ConferenceLockRequest::PrintOn(ostream & strm) const
  3112. {
  3113.   int indent = strm.precision() + 2;
  3114.   strm << "{\n";
  3115.   strm << setw(indent-1) << "}";
  3116. }
  3117. #endif
  3118.  
  3119.  
  3120. PINDEX GCC_ConferenceLockRequest::GetDataLength() const
  3121. {
  3122.   PINDEX length = 0;
  3123.   return length;
  3124. }
  3125.  
  3126.  
  3127. BOOL GCC_ConferenceLockRequest::Decode(PASN_Stream & strm)
  3128. {
  3129.   if (!PreambleDecode(strm))
  3130.     return FALSE;
  3131.  
  3132.  
  3133.   return UnknownExtensionsDecode(strm);
  3134. }
  3135.  
  3136.  
  3137. void GCC_ConferenceLockRequest::Encode(PASN_Stream & strm) const
  3138. {
  3139.   PreambleEncode(strm);
  3140.  
  3141.  
  3142.   UnknownExtensionsEncode(strm);
  3143. }
  3144.  
  3145.  
  3146. PObject * GCC_ConferenceLockRequest::Clone() const
  3147. {
  3148. #ifndef PASN_LEANANDMEAN
  3149.   PAssert(IsClass(GCC_ConferenceLockRequest::Class()), PInvalidCast);
  3150. #endif
  3151.   return new GCC_ConferenceLockRequest(*this);
  3152. }
  3153.  
  3154.  
  3155. //
  3156. // ConferenceLockIndication
  3157. //
  3158.  
  3159. GCC_ConferenceLockIndication::GCC_ConferenceLockIndication(unsigned tag, PASN_Object::TagClass tagClass)
  3160.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3161. {
  3162. }
  3163.  
  3164.  
  3165. #ifndef PASN_NOPRINTON
  3166. void GCC_ConferenceLockIndication::PrintOn(ostream & strm) const
  3167. {
  3168.   int indent = strm.precision() + 2;
  3169.   strm << "{\n";
  3170.   strm << setw(indent-1) << "}";
  3171. }
  3172. #endif
  3173.  
  3174.  
  3175. PINDEX GCC_ConferenceLockIndication::GetDataLength() const
  3176. {
  3177.   PINDEX length = 0;
  3178.   return length;
  3179. }
  3180.  
  3181.  
  3182. BOOL GCC_ConferenceLockIndication::Decode(PASN_Stream & strm)
  3183. {
  3184.   if (!PreambleDecode(strm))
  3185.     return FALSE;
  3186.  
  3187.  
  3188.   return UnknownExtensionsDecode(strm);
  3189. }
  3190.  
  3191.  
  3192. void GCC_ConferenceLockIndication::Encode(PASN_Stream & strm) const
  3193. {
  3194.   PreambleEncode(strm);
  3195.  
  3196.  
  3197.   UnknownExtensionsEncode(strm);
  3198. }
  3199.  
  3200.  
  3201. PObject * GCC_ConferenceLockIndication::Clone() const
  3202. {
  3203. #ifndef PASN_LEANANDMEAN
  3204.   PAssert(IsClass(GCC_ConferenceLockIndication::Class()), PInvalidCast);
  3205. #endif
  3206.   return new GCC_ConferenceLockIndication(*this);
  3207. }
  3208.  
  3209.  
  3210. //
  3211. // ConferenceUnlockRequest
  3212. //
  3213.  
  3214. GCC_ConferenceUnlockRequest::GCC_ConferenceUnlockRequest(unsigned tag, PASN_Object::TagClass tagClass)
  3215.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3216. {
  3217. }
  3218.  
  3219.  
  3220. #ifndef PASN_NOPRINTON
  3221. void GCC_ConferenceUnlockRequest::PrintOn(ostream & strm) const
  3222. {
  3223.   int indent = strm.precision() + 2;
  3224.   strm << "{\n";
  3225.   strm << setw(indent-1) << "}";
  3226. }
  3227. #endif
  3228.  
  3229.  
  3230. PINDEX GCC_ConferenceUnlockRequest::GetDataLength() const
  3231. {
  3232.   PINDEX length = 0;
  3233.   return length;
  3234. }
  3235.  
  3236.  
  3237. BOOL GCC_ConferenceUnlockRequest::Decode(PASN_Stream & strm)
  3238. {
  3239.   if (!PreambleDecode(strm))
  3240.     return FALSE;
  3241.  
  3242.  
  3243.   return UnknownExtensionsDecode(strm);
  3244. }
  3245.  
  3246.  
  3247. void GCC_ConferenceUnlockRequest::Encode(PASN_Stream & strm) const
  3248. {
  3249.   PreambleEncode(strm);
  3250.  
  3251.  
  3252.   UnknownExtensionsEncode(strm);
  3253. }
  3254.  
  3255.  
  3256. PObject * GCC_ConferenceUnlockRequest::Clone() const
  3257. {
  3258. #ifndef PASN_LEANANDMEAN
  3259.   PAssert(IsClass(GCC_ConferenceUnlockRequest::Class()), PInvalidCast);
  3260. #endif
  3261.   return new GCC_ConferenceUnlockRequest(*this);
  3262. }
  3263.  
  3264.  
  3265. //
  3266. // ConferenceUnlockIndication
  3267. //
  3268.  
  3269. GCC_ConferenceUnlockIndication::GCC_ConferenceUnlockIndication(unsigned tag, PASN_Object::TagClass tagClass)
  3270.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3271. {
  3272. }
  3273.  
  3274.  
  3275. #ifndef PASN_NOPRINTON
  3276. void GCC_ConferenceUnlockIndication::PrintOn(ostream & strm) const
  3277. {
  3278.   int indent = strm.precision() + 2;
  3279.   strm << "{\n";
  3280.   strm << setw(indent-1) << "}";
  3281. }
  3282. #endif
  3283.  
  3284.  
  3285. PINDEX GCC_ConferenceUnlockIndication::GetDataLength() const
  3286. {
  3287.   PINDEX length = 0;
  3288.   return length;
  3289. }
  3290.  
  3291.  
  3292. BOOL GCC_ConferenceUnlockIndication::Decode(PASN_Stream & strm)
  3293. {
  3294.   if (!PreambleDecode(strm))
  3295.     return FALSE;
  3296.  
  3297.  
  3298.   return UnknownExtensionsDecode(strm);
  3299. }
  3300.  
  3301.  
  3302. void GCC_ConferenceUnlockIndication::Encode(PASN_Stream & strm) const
  3303. {
  3304.   PreambleEncode(strm);
  3305.  
  3306.  
  3307.   UnknownExtensionsEncode(strm);
  3308. }
  3309.  
  3310.  
  3311. PObject * GCC_ConferenceUnlockIndication::Clone() const
  3312. {
  3313. #ifndef PASN_LEANANDMEAN
  3314.   PAssert(IsClass(GCC_ConferenceUnlockIndication::Class()), PInvalidCast);
  3315. #endif
  3316.   return new GCC_ConferenceUnlockIndication(*this);
  3317. }
  3318.  
  3319.  
  3320. //
  3321. // RegistryRegisterChannelRequest
  3322. //
  3323.  
  3324. GCC_RegistryRegisterChannelRequest::GCC_RegistryRegisterChannelRequest(unsigned tag, PASN_Object::TagClass tagClass)
  3325.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3326. {
  3327. }
  3328.  
  3329.  
  3330. #ifndef PASN_NOPRINTON
  3331. void GCC_RegistryRegisterChannelRequest::PrintOn(ostream & strm) const
  3332. {
  3333.   int indent = strm.precision() + 2;
  3334.   strm << "{\n";
  3335.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  3336.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  3337.   strm << setw(indent+12) << "channelID = " << setprecision(indent) << m_channelID << '\n';
  3338.   strm << setw(indent-1) << "}";
  3339. }
  3340. #endif
  3341.  
  3342.  
  3343. PObject::Comparison GCC_RegistryRegisterChannelRequest::Compare(const PObject & obj) const
  3344. {
  3345. #ifndef PASN_LEANANDMEAN
  3346.   PAssert(IsDescendant(GCC_RegistryRegisterChannelRequest::Class()), PInvalidCast);
  3347. #endif
  3348.   const GCC_RegistryRegisterChannelRequest & other = (const GCC_RegistryRegisterChannelRequest &)obj;
  3349.  
  3350.   Comparison result;
  3351.  
  3352.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  3353.     return result;
  3354.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  3355.     return result;
  3356.   if ((result = m_channelID.Compare(other.m_channelID)) != EqualTo)
  3357.     return result;
  3358.  
  3359.   return PASN_Sequence::Compare(other);
  3360. }
  3361.  
  3362.  
  3363. PINDEX GCC_RegistryRegisterChannelRequest::GetDataLength() const
  3364. {
  3365.   PINDEX length = 0;
  3366.   length += m_entityID.GetObjectLength();
  3367.   length += m_key.GetObjectLength();
  3368.   length += m_channelID.GetObjectLength();
  3369.   return length;
  3370. }
  3371.  
  3372.  
  3373. BOOL GCC_RegistryRegisterChannelRequest::Decode(PASN_Stream & strm)
  3374. {
  3375.   if (!PreambleDecode(strm))
  3376.     return FALSE;
  3377.  
  3378.   if (!m_entityID.Decode(strm))
  3379.     return FALSE;
  3380.   if (!m_key.Decode(strm))
  3381.     return FALSE;
  3382.   if (!m_channelID.Decode(strm))
  3383.     return FALSE;
  3384.  
  3385.   return UnknownExtensionsDecode(strm);
  3386. }
  3387.  
  3388.  
  3389. void GCC_RegistryRegisterChannelRequest::Encode(PASN_Stream & strm) const
  3390. {
  3391.   PreambleEncode(strm);
  3392.  
  3393.   m_entityID.Encode(strm);
  3394.   m_key.Encode(strm);
  3395.   m_channelID.Encode(strm);
  3396.  
  3397.   UnknownExtensionsEncode(strm);
  3398. }
  3399.  
  3400.  
  3401. PObject * GCC_RegistryRegisterChannelRequest::Clone() const
  3402. {
  3403. #ifndef PASN_LEANANDMEAN
  3404.   PAssert(IsClass(GCC_RegistryRegisterChannelRequest::Class()), PInvalidCast);
  3405. #endif
  3406.   return new GCC_RegistryRegisterChannelRequest(*this);
  3407. }
  3408.  
  3409.  
  3410. //
  3411. // RegistryAssignTokenRequest
  3412. //
  3413.  
  3414. GCC_RegistryAssignTokenRequest::GCC_RegistryAssignTokenRequest(unsigned tag, PASN_Object::TagClass tagClass)
  3415.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3416. {
  3417. }
  3418.  
  3419.  
  3420. #ifndef PASN_NOPRINTON
  3421. void GCC_RegistryAssignTokenRequest::PrintOn(ostream & strm) const
  3422. {
  3423.   int indent = strm.precision() + 2;
  3424.   strm << "{\n";
  3425.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  3426.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  3427.   strm << setw(indent-1) << "}";
  3428. }
  3429. #endif
  3430.  
  3431.  
  3432. PObject::Comparison GCC_RegistryAssignTokenRequest::Compare(const PObject & obj) const
  3433. {
  3434. #ifndef PASN_LEANANDMEAN
  3435.   PAssert(IsDescendant(GCC_RegistryAssignTokenRequest::Class()), PInvalidCast);
  3436. #endif
  3437.   const GCC_RegistryAssignTokenRequest & other = (const GCC_RegistryAssignTokenRequest &)obj;
  3438.  
  3439.   Comparison result;
  3440.  
  3441.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  3442.     return result;
  3443.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  3444.     return result;
  3445.  
  3446.   return PASN_Sequence::Compare(other);
  3447. }
  3448.  
  3449.  
  3450. PINDEX GCC_RegistryAssignTokenRequest::GetDataLength() const
  3451. {
  3452.   PINDEX length = 0;
  3453.   length += m_entityID.GetObjectLength();
  3454.   length += m_key.GetObjectLength();
  3455.   return length;
  3456. }
  3457.  
  3458.  
  3459. BOOL GCC_RegistryAssignTokenRequest::Decode(PASN_Stream & strm)
  3460. {
  3461.   if (!PreambleDecode(strm))
  3462.     return FALSE;
  3463.  
  3464.   if (!m_entityID.Decode(strm))
  3465.     return FALSE;
  3466.   if (!m_key.Decode(strm))
  3467.     return FALSE;
  3468.  
  3469.   return UnknownExtensionsDecode(strm);
  3470. }
  3471.  
  3472.  
  3473. void GCC_RegistryAssignTokenRequest::Encode(PASN_Stream & strm) const
  3474. {
  3475.   PreambleEncode(strm);
  3476.  
  3477.   m_entityID.Encode(strm);
  3478.   m_key.Encode(strm);
  3479.  
  3480.   UnknownExtensionsEncode(strm);
  3481. }
  3482.  
  3483.  
  3484. PObject * GCC_RegistryAssignTokenRequest::Clone() const
  3485. {
  3486. #ifndef PASN_LEANANDMEAN
  3487.   PAssert(IsClass(GCC_RegistryAssignTokenRequest::Class()), PInvalidCast);
  3488. #endif
  3489.   return new GCC_RegistryAssignTokenRequest(*this);
  3490. }
  3491.  
  3492.  
  3493. //
  3494. // RegistrySetParameterRequest
  3495. //
  3496.  
  3497. GCC_RegistrySetParameterRequest::GCC_RegistrySetParameterRequest(unsigned tag, PASN_Object::TagClass tagClass)
  3498.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  3499. {
  3500.   m_parameter.SetConstraints(PASN_Object::FixedConstraint, 0, 64);
  3501. }
  3502.  
  3503.  
  3504. #ifndef PASN_NOPRINTON
  3505. void GCC_RegistrySetParameterRequest::PrintOn(ostream & strm) const
  3506. {
  3507.   int indent = strm.precision() + 2;
  3508.   strm << "{\n";
  3509.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  3510.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  3511.   strm << setw(indent+12) << "parameter = " << setprecision(indent) << m_parameter << '\n';
  3512.   if (HasOptionalField(e_modificationRights))
  3513.     strm << setw(indent+21) << "modificationRights = " << setprecision(indent) << m_modificationRights << '\n';
  3514.   strm << setw(indent-1) << "}";
  3515. }
  3516. #endif
  3517.  
  3518.  
  3519. PObject::Comparison GCC_RegistrySetParameterRequest::Compare(const PObject & obj) const
  3520. {
  3521. #ifndef PASN_LEANANDMEAN
  3522.   PAssert(IsDescendant(GCC_RegistrySetParameterRequest::Class()), PInvalidCast);
  3523. #endif
  3524.   const GCC_RegistrySetParameterRequest & other = (const GCC_RegistrySetParameterRequest &)obj;
  3525.  
  3526.   Comparison result;
  3527.  
  3528.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  3529.     return result;
  3530.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  3531.     return result;
  3532.   if ((result = m_parameter.Compare(other.m_parameter)) != EqualTo)
  3533.     return result;
  3534.   if ((result = m_modificationRights.Compare(other.m_modificationRights)) != EqualTo)
  3535.     return result;
  3536.  
  3537.   return PASN_Sequence::Compare(other);
  3538. }
  3539.  
  3540.  
  3541. PINDEX GCC_RegistrySetParameterRequest::GetDataLength() const
  3542. {
  3543.   PINDEX length = 0;
  3544.   length += m_entityID.GetObjectLength();
  3545.   length += m_key.GetObjectLength();
  3546.   length += m_parameter.GetObjectLength();
  3547.   if (HasOptionalField(e_modificationRights))
  3548.     length += m_modificationRights.GetObjectLength();
  3549.   return length;
  3550. }
  3551.  
  3552.  
  3553. BOOL GCC_RegistrySetParameterRequest::Decode(PASN_Stream & strm)
  3554. {
  3555.   if (!PreambleDecode(strm))
  3556.     return FALSE;
  3557.  
  3558.   if (!m_entityID.Decode(strm))
  3559.     return FALSE;
  3560.   if (!m_key.Decode(strm))
  3561.     return FALSE;
  3562.   if (!m_parameter.Decode(strm))
  3563.     return FALSE;
  3564.   if (HasOptionalField(e_modificationRights) && !m_modificationRights.Decode(strm))
  3565.     return FALSE;
  3566.  
  3567.   return UnknownExtensionsDecode(strm);
  3568. }
  3569.  
  3570.  
  3571. void GCC_RegistrySetParameterRequest::Encode(PASN_Stream & strm) const
  3572. {
  3573.   PreambleEncode(strm);
  3574.  
  3575.   m_entityID.Encode(strm);
  3576.   m_key.Encode(strm);
  3577.   m_parameter.Encode(strm);
  3578.   if (HasOptionalField(e_modificationRights))
  3579.     m_modificationRights.Encode(strm);
  3580.  
  3581.   UnknownExtensionsEncode(strm);
  3582. }
  3583.  
  3584.  
  3585. PObject * GCC_RegistrySetParameterRequest::Clone() const
  3586. {
  3587. #ifndef PASN_LEANANDMEAN
  3588.   PAssert(IsClass(GCC_RegistrySetParameterRequest::Class()), PInvalidCast);
  3589. #endif
  3590.   return new GCC_RegistrySetParameterRequest(*this);
  3591. }
  3592.  
  3593.  
  3594. //
  3595. // RegistryRetrieveEntryRequest
  3596. //
  3597.  
  3598. GCC_RegistryRetrieveEntryRequest::GCC_RegistryRetrieveEntryRequest(unsigned tag, PASN_Object::TagClass tagClass)
  3599.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3600. {
  3601. }
  3602.  
  3603.  
  3604. #ifndef PASN_NOPRINTON
  3605. void GCC_RegistryRetrieveEntryRequest::PrintOn(ostream & strm) const
  3606. {
  3607.   int indent = strm.precision() + 2;
  3608.   strm << "{\n";
  3609.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  3610.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  3611.   strm << setw(indent-1) << "}";
  3612. }
  3613. #endif
  3614.  
  3615.  
  3616. PObject::Comparison GCC_RegistryRetrieveEntryRequest::Compare(const PObject & obj) const
  3617. {
  3618. #ifndef PASN_LEANANDMEAN
  3619.   PAssert(IsDescendant(GCC_RegistryRetrieveEntryRequest::Class()), PInvalidCast);
  3620. #endif
  3621.   const GCC_RegistryRetrieveEntryRequest & other = (const GCC_RegistryRetrieveEntryRequest &)obj;
  3622.  
  3623.   Comparison result;
  3624.  
  3625.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  3626.     return result;
  3627.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  3628.     return result;
  3629.  
  3630.   return PASN_Sequence::Compare(other);
  3631. }
  3632.  
  3633.  
  3634. PINDEX GCC_RegistryRetrieveEntryRequest::GetDataLength() const
  3635. {
  3636.   PINDEX length = 0;
  3637.   length += m_entityID.GetObjectLength();
  3638.   length += m_key.GetObjectLength();
  3639.   return length;
  3640. }
  3641.  
  3642.  
  3643. BOOL GCC_RegistryRetrieveEntryRequest::Decode(PASN_Stream & strm)
  3644. {
  3645.   if (!PreambleDecode(strm))
  3646.     return FALSE;
  3647.  
  3648.   if (!m_entityID.Decode(strm))
  3649.     return FALSE;
  3650.   if (!m_key.Decode(strm))
  3651.     return FALSE;
  3652.  
  3653.   return UnknownExtensionsDecode(strm);
  3654. }
  3655.  
  3656.  
  3657. void GCC_RegistryRetrieveEntryRequest::Encode(PASN_Stream & strm) const
  3658. {
  3659.   PreambleEncode(strm);
  3660.  
  3661.   m_entityID.Encode(strm);
  3662.   m_key.Encode(strm);
  3663.  
  3664.   UnknownExtensionsEncode(strm);
  3665. }
  3666.  
  3667.  
  3668. PObject * GCC_RegistryRetrieveEntryRequest::Clone() const
  3669. {
  3670. #ifndef PASN_LEANANDMEAN
  3671.   PAssert(IsClass(GCC_RegistryRetrieveEntryRequest::Class()), PInvalidCast);
  3672. #endif
  3673.   return new GCC_RegistryRetrieveEntryRequest(*this);
  3674. }
  3675.  
  3676.  
  3677. //
  3678. // RegistryDeleteEntryRequest
  3679. //
  3680.  
  3681. GCC_RegistryDeleteEntryRequest::GCC_RegistryDeleteEntryRequest(unsigned tag, PASN_Object::TagClass tagClass)
  3682.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3683. {
  3684. }
  3685.  
  3686.  
  3687. #ifndef PASN_NOPRINTON
  3688. void GCC_RegistryDeleteEntryRequest::PrintOn(ostream & strm) const
  3689. {
  3690.   int indent = strm.precision() + 2;
  3691.   strm << "{\n";
  3692.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  3693.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  3694.   strm << setw(indent-1) << "}";
  3695. }
  3696. #endif
  3697.  
  3698.  
  3699. PObject::Comparison GCC_RegistryDeleteEntryRequest::Compare(const PObject & obj) const
  3700. {
  3701. #ifndef PASN_LEANANDMEAN
  3702.   PAssert(IsDescendant(GCC_RegistryDeleteEntryRequest::Class()), PInvalidCast);
  3703. #endif
  3704.   const GCC_RegistryDeleteEntryRequest & other = (const GCC_RegistryDeleteEntryRequest &)obj;
  3705.  
  3706.   Comparison result;
  3707.  
  3708.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  3709.     return result;
  3710.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  3711.     return result;
  3712.  
  3713.   return PASN_Sequence::Compare(other);
  3714. }
  3715.  
  3716.  
  3717. PINDEX GCC_RegistryDeleteEntryRequest::GetDataLength() const
  3718. {
  3719.   PINDEX length = 0;
  3720.   length += m_entityID.GetObjectLength();
  3721.   length += m_key.GetObjectLength();
  3722.   return length;
  3723. }
  3724.  
  3725.  
  3726. BOOL GCC_RegistryDeleteEntryRequest::Decode(PASN_Stream & strm)
  3727. {
  3728.   if (!PreambleDecode(strm))
  3729.     return FALSE;
  3730.  
  3731.   if (!m_entityID.Decode(strm))
  3732.     return FALSE;
  3733.   if (!m_key.Decode(strm))
  3734.     return FALSE;
  3735.  
  3736.   return UnknownExtensionsDecode(strm);
  3737. }
  3738.  
  3739.  
  3740. void GCC_RegistryDeleteEntryRequest::Encode(PASN_Stream & strm) const
  3741. {
  3742.   PreambleEncode(strm);
  3743.  
  3744.   m_entityID.Encode(strm);
  3745.   m_key.Encode(strm);
  3746.  
  3747.   UnknownExtensionsEncode(strm);
  3748. }
  3749.  
  3750.  
  3751. PObject * GCC_RegistryDeleteEntryRequest::Clone() const
  3752. {
  3753. #ifndef PASN_LEANANDMEAN
  3754.   PAssert(IsClass(GCC_RegistryDeleteEntryRequest::Class()), PInvalidCast);
  3755. #endif
  3756.   return new GCC_RegistryDeleteEntryRequest(*this);
  3757. }
  3758.  
  3759.  
  3760. //
  3761. // RegistryMonitorEntryRequest
  3762. //
  3763.  
  3764. GCC_RegistryMonitorEntryRequest::GCC_RegistryMonitorEntryRequest(unsigned tag, PASN_Object::TagClass tagClass)
  3765.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3766. {
  3767. }
  3768.  
  3769.  
  3770. #ifndef PASN_NOPRINTON
  3771. void GCC_RegistryMonitorEntryRequest::PrintOn(ostream & strm) const
  3772. {
  3773.   int indent = strm.precision() + 2;
  3774.   strm << "{\n";
  3775.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  3776.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  3777.   strm << setw(indent-1) << "}";
  3778. }
  3779. #endif
  3780.  
  3781.  
  3782. PObject::Comparison GCC_RegistryMonitorEntryRequest::Compare(const PObject & obj) const
  3783. {
  3784. #ifndef PASN_LEANANDMEAN
  3785.   PAssert(IsDescendant(GCC_RegistryMonitorEntryRequest::Class()), PInvalidCast);
  3786. #endif
  3787.   const GCC_RegistryMonitorEntryRequest & other = (const GCC_RegistryMonitorEntryRequest &)obj;
  3788.  
  3789.   Comparison result;
  3790.  
  3791.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  3792.     return result;
  3793.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  3794.     return result;
  3795.  
  3796.   return PASN_Sequence::Compare(other);
  3797. }
  3798.  
  3799.  
  3800. PINDEX GCC_RegistryMonitorEntryRequest::GetDataLength() const
  3801. {
  3802.   PINDEX length = 0;
  3803.   length += m_entityID.GetObjectLength();
  3804.   length += m_key.GetObjectLength();
  3805.   return length;
  3806. }
  3807.  
  3808.  
  3809. BOOL GCC_RegistryMonitorEntryRequest::Decode(PASN_Stream & strm)
  3810. {
  3811.   if (!PreambleDecode(strm))
  3812.     return FALSE;
  3813.  
  3814.   if (!m_entityID.Decode(strm))
  3815.     return FALSE;
  3816.   if (!m_key.Decode(strm))
  3817.     return FALSE;
  3818.  
  3819.   return UnknownExtensionsDecode(strm);
  3820. }
  3821.  
  3822.  
  3823. void GCC_RegistryMonitorEntryRequest::Encode(PASN_Stream & strm) const
  3824. {
  3825.   PreambleEncode(strm);
  3826.  
  3827.   m_entityID.Encode(strm);
  3828.   m_key.Encode(strm);
  3829.  
  3830.   UnknownExtensionsEncode(strm);
  3831. }
  3832.  
  3833.  
  3834. PObject * GCC_RegistryMonitorEntryRequest::Clone() const
  3835. {
  3836. #ifndef PASN_LEANANDMEAN
  3837.   PAssert(IsClass(GCC_RegistryMonitorEntryRequest::Class()), PInvalidCast);
  3838. #endif
  3839.   return new GCC_RegistryMonitorEntryRequest(*this);
  3840. }
  3841.  
  3842.  
  3843. //
  3844. // RegistryMonitorEntryIndication
  3845. //
  3846.  
  3847. GCC_RegistryMonitorEntryIndication::GCC_RegistryMonitorEntryIndication(unsigned tag, PASN_Object::TagClass tagClass)
  3848.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  3849. {
  3850. }
  3851.  
  3852.  
  3853. #ifndef PASN_NOPRINTON
  3854. void GCC_RegistryMonitorEntryIndication::PrintOn(ostream & strm) const
  3855. {
  3856.   int indent = strm.precision() + 2;
  3857.   strm << "{\n";
  3858.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  3859.   strm << setw(indent+7) << "item = " << setprecision(indent) << m_item << '\n';
  3860.   strm << setw(indent+8) << "owner = " << setprecision(indent) << m_owner << '\n';
  3861.   if (HasOptionalField(e_modificationRights))
  3862.     strm << setw(indent+21) << "modificationRights = " << setprecision(indent) << m_modificationRights << '\n';
  3863.   strm << setw(indent-1) << "}";
  3864. }
  3865. #endif
  3866.  
  3867.  
  3868. PObject::Comparison GCC_RegistryMonitorEntryIndication::Compare(const PObject & obj) const
  3869. {
  3870. #ifndef PASN_LEANANDMEAN
  3871.   PAssert(IsDescendant(GCC_RegistryMonitorEntryIndication::Class()), PInvalidCast);
  3872. #endif
  3873.   const GCC_RegistryMonitorEntryIndication & other = (const GCC_RegistryMonitorEntryIndication &)obj;
  3874.  
  3875.   Comparison result;
  3876.  
  3877.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  3878.     return result;
  3879.   if ((result = m_item.Compare(other.m_item)) != EqualTo)
  3880.     return result;
  3881.   if ((result = m_owner.Compare(other.m_owner)) != EqualTo)
  3882.     return result;
  3883.   if ((result = m_modificationRights.Compare(other.m_modificationRights)) != EqualTo)
  3884.     return result;
  3885.  
  3886.   return PASN_Sequence::Compare(other);
  3887. }
  3888.  
  3889.  
  3890. PINDEX GCC_RegistryMonitorEntryIndication::GetDataLength() const
  3891. {
  3892.   PINDEX length = 0;
  3893.   length += m_key.GetObjectLength();
  3894.   length += m_item.GetObjectLength();
  3895.   length += m_owner.GetObjectLength();
  3896.   if (HasOptionalField(e_modificationRights))
  3897.     length += m_modificationRights.GetObjectLength();
  3898.   return length;
  3899. }
  3900.  
  3901.  
  3902. BOOL GCC_RegistryMonitorEntryIndication::Decode(PASN_Stream & strm)
  3903. {
  3904.   if (!PreambleDecode(strm))
  3905.     return FALSE;
  3906.  
  3907.   if (!m_key.Decode(strm))
  3908.     return FALSE;
  3909.   if (!m_item.Decode(strm))
  3910.     return FALSE;
  3911.   if (!m_owner.Decode(strm))
  3912.     return FALSE;
  3913.   if (HasOptionalField(e_modificationRights) && !m_modificationRights.Decode(strm))
  3914.     return FALSE;
  3915.  
  3916.   return UnknownExtensionsDecode(strm);
  3917. }
  3918.  
  3919.  
  3920. void GCC_RegistryMonitorEntryIndication::Encode(PASN_Stream & strm) const
  3921. {
  3922.   PreambleEncode(strm);
  3923.  
  3924.   m_key.Encode(strm);
  3925.   m_item.Encode(strm);
  3926.   m_owner.Encode(strm);
  3927.   if (HasOptionalField(e_modificationRights))
  3928.     m_modificationRights.Encode(strm);
  3929.  
  3930.   UnknownExtensionsEncode(strm);
  3931. }
  3932.  
  3933.  
  3934. PObject * GCC_RegistryMonitorEntryIndication::Clone() const
  3935. {
  3936. #ifndef PASN_LEANANDMEAN
  3937.   PAssert(IsClass(GCC_RegistryMonitorEntryIndication::Class()), PInvalidCast);
  3938. #endif
  3939.   return new GCC_RegistryMonitorEntryIndication(*this);
  3940. }
  3941.  
  3942.  
  3943. //
  3944. // RegistryAllocateHandleRequest
  3945. //
  3946.  
  3947. GCC_RegistryAllocateHandleRequest::GCC_RegistryAllocateHandleRequest(unsigned tag, PASN_Object::TagClass tagClass)
  3948.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  3949. {
  3950.   m_numberOfHandles.SetConstraints(PASN_Object::FixedConstraint, 1, 1024);
  3951. }
  3952.  
  3953.  
  3954. #ifndef PASN_NOPRINTON
  3955. void GCC_RegistryAllocateHandleRequest::PrintOn(ostream & strm) const
  3956. {
  3957.   int indent = strm.precision() + 2;
  3958.   strm << "{\n";
  3959.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  3960.   strm << setw(indent+18) << "numberOfHandles = " << setprecision(indent) << m_numberOfHandles << '\n';
  3961.   strm << setw(indent-1) << "}";
  3962. }
  3963. #endif
  3964.  
  3965.  
  3966. PObject::Comparison GCC_RegistryAllocateHandleRequest::Compare(const PObject & obj) const
  3967. {
  3968. #ifndef PASN_LEANANDMEAN
  3969.   PAssert(IsDescendant(GCC_RegistryAllocateHandleRequest::Class()), PInvalidCast);
  3970. #endif
  3971.   const GCC_RegistryAllocateHandleRequest & other = (const GCC_RegistryAllocateHandleRequest &)obj;
  3972.  
  3973.   Comparison result;
  3974.  
  3975.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  3976.     return result;
  3977.   if ((result = m_numberOfHandles.Compare(other.m_numberOfHandles)) != EqualTo)
  3978.     return result;
  3979.  
  3980.   return PASN_Sequence::Compare(other);
  3981. }
  3982.  
  3983.  
  3984. PINDEX GCC_RegistryAllocateHandleRequest::GetDataLength() const
  3985. {
  3986.   PINDEX length = 0;
  3987.   length += m_entityID.GetObjectLength();
  3988.   length += m_numberOfHandles.GetObjectLength();
  3989.   return length;
  3990. }
  3991.  
  3992.  
  3993. BOOL GCC_RegistryAllocateHandleRequest::Decode(PASN_Stream & strm)
  3994. {
  3995.   if (!PreambleDecode(strm))
  3996.     return FALSE;
  3997.  
  3998.   if (!m_entityID.Decode(strm))
  3999.     return FALSE;
  4000.   if (!m_numberOfHandles.Decode(strm))
  4001.     return FALSE;
  4002.  
  4003.   return UnknownExtensionsDecode(strm);
  4004. }
  4005.  
  4006.  
  4007. void GCC_RegistryAllocateHandleRequest::Encode(PASN_Stream & strm) const
  4008. {
  4009.   PreambleEncode(strm);
  4010.  
  4011.   m_entityID.Encode(strm);
  4012.   m_numberOfHandles.Encode(strm);
  4013.  
  4014.   UnknownExtensionsEncode(strm);
  4015. }
  4016.  
  4017.  
  4018. PObject * GCC_RegistryAllocateHandleRequest::Clone() const
  4019. {
  4020. #ifndef PASN_LEANANDMEAN
  4021.   PAssert(IsClass(GCC_RegistryAllocateHandleRequest::Class()), PInvalidCast);
  4022. #endif
  4023.   return new GCC_RegistryAllocateHandleRequest(*this);
  4024. }
  4025.  
  4026.  
  4027. //
  4028. // ConductorAssignIndication
  4029. //
  4030.  
  4031. GCC_ConductorAssignIndication::GCC_ConductorAssignIndication(unsigned tag, PASN_Object::TagClass tagClass)
  4032.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  4033. {
  4034. }
  4035.  
  4036.  
  4037. #ifndef PASN_NOPRINTON
  4038. void GCC_ConductorAssignIndication::PrintOn(ostream & strm) const
  4039. {
  4040.   int indent = strm.precision() + 2;
  4041.   strm << "{\n";
  4042.   strm << setw(indent+17) << "conductingNode = " << setprecision(indent) << m_conductingNode << '\n';
  4043.   strm << setw(indent-1) << "}";
  4044. }
  4045. #endif
  4046.  
  4047.  
  4048. PObject::Comparison GCC_ConductorAssignIndication::Compare(const PObject & obj) const
  4049. {
  4050. #ifndef PASN_LEANANDMEAN
  4051.   PAssert(IsDescendant(GCC_ConductorAssignIndication::Class()), PInvalidCast);
  4052. #endif
  4053.   const GCC_ConductorAssignIndication & other = (const GCC_ConductorAssignIndication &)obj;
  4054.  
  4055.   Comparison result;
  4056.  
  4057.   if ((result = m_conductingNode.Compare(other.m_conductingNode)) != EqualTo)
  4058.     return result;
  4059.  
  4060.   return PASN_Sequence::Compare(other);
  4061. }
  4062.  
  4063.  
  4064. PINDEX GCC_ConductorAssignIndication::GetDataLength() const
  4065. {
  4066.   PINDEX length = 0;
  4067.   length += m_conductingNode.GetObjectLength();
  4068.   return length;
  4069. }
  4070.  
  4071.  
  4072. BOOL GCC_ConductorAssignIndication::Decode(PASN_Stream & strm)
  4073. {
  4074.   if (!PreambleDecode(strm))
  4075.     return FALSE;
  4076.  
  4077.   if (!m_conductingNode.Decode(strm))
  4078.     return FALSE;
  4079.  
  4080.   return UnknownExtensionsDecode(strm);
  4081. }
  4082.  
  4083.  
  4084. void GCC_ConductorAssignIndication::Encode(PASN_Stream & strm) const
  4085. {
  4086.   PreambleEncode(strm);
  4087.  
  4088.   m_conductingNode.Encode(strm);
  4089.  
  4090.   UnknownExtensionsEncode(strm);
  4091. }
  4092.  
  4093.  
  4094. PObject * GCC_ConductorAssignIndication::Clone() const
  4095. {
  4096. #ifndef PASN_LEANANDMEAN
  4097.   PAssert(IsClass(GCC_ConductorAssignIndication::Class()), PInvalidCast);
  4098. #endif
  4099.   return new GCC_ConductorAssignIndication(*this);
  4100. }
  4101.  
  4102.  
  4103. //
  4104. // ConductorReleaseIndication
  4105. //
  4106.  
  4107. GCC_ConductorReleaseIndication::GCC_ConductorReleaseIndication(unsigned tag, PASN_Object::TagClass tagClass)
  4108.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  4109. {
  4110. }
  4111.  
  4112.  
  4113. #ifndef PASN_NOPRINTON
  4114. void GCC_ConductorReleaseIndication::PrintOn(ostream & strm) const
  4115. {
  4116.   int indent = strm.precision() + 2;
  4117.   strm << "{\n";
  4118.   strm << setw(indent-1) << "}";
  4119. }
  4120. #endif
  4121.  
  4122.  
  4123. PINDEX GCC_ConductorReleaseIndication::GetDataLength() const
  4124. {
  4125.   PINDEX length = 0;
  4126.   return length;
  4127. }
  4128.  
  4129.  
  4130. BOOL GCC_ConductorReleaseIndication::Decode(PASN_Stream & strm)
  4131. {
  4132.   if (!PreambleDecode(strm))
  4133.     return FALSE;
  4134.  
  4135.  
  4136.   return UnknownExtensionsDecode(strm);
  4137. }
  4138.  
  4139.  
  4140. void GCC_ConductorReleaseIndication::Encode(PASN_Stream & strm) const
  4141. {
  4142.   PreambleEncode(strm);
  4143.  
  4144.  
  4145.   UnknownExtensionsEncode(strm);
  4146. }
  4147.  
  4148.  
  4149. PObject * GCC_ConductorReleaseIndication::Clone() const
  4150. {
  4151. #ifndef PASN_LEANANDMEAN
  4152.   PAssert(IsClass(GCC_ConductorReleaseIndication::Class()), PInvalidCast);
  4153. #endif
  4154.   return new GCC_ConductorReleaseIndication(*this);
  4155. }
  4156.  
  4157.  
  4158. //
  4159. // ConductorPermissionAskIndication
  4160. //
  4161.  
  4162. GCC_ConductorPermissionAskIndication::GCC_ConductorPermissionAskIndication(unsigned tag, PASN_Object::TagClass tagClass)
  4163.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  4164. {
  4165. }
  4166.  
  4167.  
  4168. #ifndef PASN_NOPRINTON
  4169. void GCC_ConductorPermissionAskIndication::PrintOn(ostream & strm) const
  4170. {
  4171.   int indent = strm.precision() + 2;
  4172.   strm << "{\n";
  4173.   strm << setw(indent+12) << "grantFlag = " << setprecision(indent) << m_grantFlag << '\n';
  4174.   strm << setw(indent-1) << "}";
  4175. }
  4176. #endif
  4177.  
  4178.  
  4179. PObject::Comparison GCC_ConductorPermissionAskIndication::Compare(const PObject & obj) const
  4180. {
  4181. #ifndef PASN_LEANANDMEAN
  4182.   PAssert(IsDescendant(GCC_ConductorPermissionAskIndication::Class()), PInvalidCast);
  4183. #endif
  4184.   const GCC_ConductorPermissionAskIndication & other = (const GCC_ConductorPermissionAskIndication &)obj;
  4185.  
  4186.   Comparison result;
  4187.  
  4188.   if ((result = m_grantFlag.Compare(other.m_grantFlag)) != EqualTo)
  4189.     return result;
  4190.  
  4191.   return PASN_Sequence::Compare(other);
  4192. }
  4193.  
  4194.  
  4195. PINDEX GCC_ConductorPermissionAskIndication::GetDataLength() const
  4196. {
  4197.   PINDEX length = 0;
  4198.   length += m_grantFlag.GetObjectLength();
  4199.   return length;
  4200. }
  4201.  
  4202.  
  4203. BOOL GCC_ConductorPermissionAskIndication::Decode(PASN_Stream & strm)
  4204. {
  4205.   if (!PreambleDecode(strm))
  4206.     return FALSE;
  4207.  
  4208.   if (!m_grantFlag.Decode(strm))
  4209.     return FALSE;
  4210.  
  4211.   return UnknownExtensionsDecode(strm);
  4212. }
  4213.  
  4214.  
  4215. void GCC_ConductorPermissionAskIndication::Encode(PASN_Stream & strm) const
  4216. {
  4217.   PreambleEncode(strm);
  4218.  
  4219.   m_grantFlag.Encode(strm);
  4220.  
  4221.   UnknownExtensionsEncode(strm);
  4222. }
  4223.  
  4224.  
  4225. PObject * GCC_ConductorPermissionAskIndication::Clone() const
  4226. {
  4227. #ifndef PASN_LEANANDMEAN
  4228.   PAssert(IsClass(GCC_ConductorPermissionAskIndication::Class()), PInvalidCast);
  4229. #endif
  4230.   return new GCC_ConductorPermissionAskIndication(*this);
  4231. }
  4232.  
  4233.  
  4234. //
  4235. // ConferenceTimeRemainingIndication
  4236. //
  4237.  
  4238. GCC_ConferenceTimeRemainingIndication::GCC_ConferenceTimeRemainingIndication(unsigned tag, PASN_Object::TagClass tagClass)
  4239.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  4240. {
  4241. }
  4242.  
  4243.  
  4244. #ifndef PASN_NOPRINTON
  4245. void GCC_ConferenceTimeRemainingIndication::PrintOn(ostream & strm) const
  4246. {
  4247.   int indent = strm.precision() + 2;
  4248.   strm << "{\n";
  4249.   strm << setw(indent+16) << "timeRemaining = " << setprecision(indent) << m_timeRemaining << '\n';
  4250.   if (HasOptionalField(e_nodeID))
  4251.     strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  4252.   strm << setw(indent-1) << "}";
  4253. }
  4254. #endif
  4255.  
  4256.  
  4257. PObject::Comparison GCC_ConferenceTimeRemainingIndication::Compare(const PObject & obj) const
  4258. {
  4259. #ifndef PASN_LEANANDMEAN
  4260.   PAssert(IsDescendant(GCC_ConferenceTimeRemainingIndication::Class()), PInvalidCast);
  4261. #endif
  4262.   const GCC_ConferenceTimeRemainingIndication & other = (const GCC_ConferenceTimeRemainingIndication &)obj;
  4263.  
  4264.   Comparison result;
  4265.  
  4266.   if ((result = m_timeRemaining.Compare(other.m_timeRemaining)) != EqualTo)
  4267.     return result;
  4268.   if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
  4269.     return result;
  4270.  
  4271.   return PASN_Sequence::Compare(other);
  4272. }
  4273.  
  4274.  
  4275. PINDEX GCC_ConferenceTimeRemainingIndication::GetDataLength() const
  4276. {
  4277.   PINDEX length = 0;
  4278.   length += m_timeRemaining.GetObjectLength();
  4279.   if (HasOptionalField(e_nodeID))
  4280.     length += m_nodeID.GetObjectLength();
  4281.   return length;
  4282. }
  4283.  
  4284.  
  4285. BOOL GCC_ConferenceTimeRemainingIndication::Decode(PASN_Stream & strm)
  4286. {
  4287.   if (!PreambleDecode(strm))
  4288.     return FALSE;
  4289.  
  4290.   if (!m_timeRemaining.Decode(strm))
  4291.     return FALSE;
  4292.   if (HasOptionalField(e_nodeID) && !m_nodeID.Decode(strm))
  4293.     return FALSE;
  4294.  
  4295.   return UnknownExtensionsDecode(strm);
  4296. }
  4297.  
  4298.  
  4299. void GCC_ConferenceTimeRemainingIndication::Encode(PASN_Stream & strm) const
  4300. {
  4301.   PreambleEncode(strm);
  4302.  
  4303.   m_timeRemaining.Encode(strm);
  4304.   if (HasOptionalField(e_nodeID))
  4305.     m_nodeID.Encode(strm);
  4306.  
  4307.   UnknownExtensionsEncode(strm);
  4308. }
  4309.  
  4310.  
  4311. PObject * GCC_ConferenceTimeRemainingIndication::Clone() const
  4312. {
  4313. #ifndef PASN_LEANANDMEAN
  4314.   PAssert(IsClass(GCC_ConferenceTimeRemainingIndication::Class()), PInvalidCast);
  4315. #endif
  4316.   return new GCC_ConferenceTimeRemainingIndication(*this);
  4317. }
  4318.  
  4319.  
  4320. //
  4321. // ConferenceTimeInquireIndication
  4322. //
  4323.  
  4324. GCC_ConferenceTimeInquireIndication::GCC_ConferenceTimeInquireIndication(unsigned tag, PASN_Object::TagClass tagClass)
  4325.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  4326. {
  4327. }
  4328.  
  4329.  
  4330. #ifndef PASN_NOPRINTON
  4331. void GCC_ConferenceTimeInquireIndication::PrintOn(ostream & strm) const
  4332. {
  4333.   int indent = strm.precision() + 2;
  4334.   strm << "{\n";
  4335.   strm << setw(indent+23) << "nodeSpecificTimeFlag = " << setprecision(indent) << m_nodeSpecificTimeFlag << '\n';
  4336.   strm << setw(indent-1) << "}";
  4337. }
  4338. #endif
  4339.  
  4340.  
  4341. PObject::Comparison GCC_ConferenceTimeInquireIndication::Compare(const PObject & obj) const
  4342. {
  4343. #ifndef PASN_LEANANDMEAN
  4344.   PAssert(IsDescendant(GCC_ConferenceTimeInquireIndication::Class()), PInvalidCast);
  4345. #endif
  4346.   const GCC_ConferenceTimeInquireIndication & other = (const GCC_ConferenceTimeInquireIndication &)obj;
  4347.  
  4348.   Comparison result;
  4349.  
  4350.   if ((result = m_nodeSpecificTimeFlag.Compare(other.m_nodeSpecificTimeFlag)) != EqualTo)
  4351.     return result;
  4352.  
  4353.   return PASN_Sequence::Compare(other);
  4354. }
  4355.  
  4356.  
  4357. PINDEX GCC_ConferenceTimeInquireIndication::GetDataLength() const
  4358. {
  4359.   PINDEX length = 0;
  4360.   length += m_nodeSpecificTimeFlag.GetObjectLength();
  4361.   return length;
  4362. }
  4363.  
  4364.  
  4365. BOOL GCC_ConferenceTimeInquireIndication::Decode(PASN_Stream & strm)
  4366. {
  4367.   if (!PreambleDecode(strm))
  4368.     return FALSE;
  4369.  
  4370.   if (!m_nodeSpecificTimeFlag.Decode(strm))
  4371.     return FALSE;
  4372.  
  4373.   return UnknownExtensionsDecode(strm);
  4374. }
  4375.  
  4376.  
  4377. void GCC_ConferenceTimeInquireIndication::Encode(PASN_Stream & strm) const
  4378. {
  4379.   PreambleEncode(strm);
  4380.  
  4381.   m_nodeSpecificTimeFlag.Encode(strm);
  4382.  
  4383.   UnknownExtensionsEncode(strm);
  4384. }
  4385.  
  4386.  
  4387. PObject * GCC_ConferenceTimeInquireIndication::Clone() const
  4388. {
  4389. #ifndef PASN_LEANANDMEAN
  4390.   PAssert(IsClass(GCC_ConferenceTimeInquireIndication::Class()), PInvalidCast);
  4391. #endif
  4392.   return new GCC_ConferenceTimeInquireIndication(*this);
  4393. }
  4394.  
  4395.  
  4396. //
  4397. // ConferenceTimeExtendIndication
  4398. //
  4399.  
  4400. GCC_ConferenceTimeExtendIndication::GCC_ConferenceTimeExtendIndication(unsigned tag, PASN_Object::TagClass tagClass)
  4401.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  4402. {
  4403. }
  4404.  
  4405.  
  4406. #ifndef PASN_NOPRINTON
  4407. void GCC_ConferenceTimeExtendIndication::PrintOn(ostream & strm) const
  4408. {
  4409.   int indent = strm.precision() + 2;
  4410.   strm << "{\n";
  4411.   strm << setw(indent+15) << "timeToExtend = " << setprecision(indent) << m_timeToExtend << '\n';
  4412.   strm << setw(indent+23) << "nodeSpecificTimeFlag = " << setprecision(indent) << m_nodeSpecificTimeFlag << '\n';
  4413.   strm << setw(indent-1) << "}";
  4414. }
  4415. #endif
  4416.  
  4417.  
  4418. PObject::Comparison GCC_ConferenceTimeExtendIndication::Compare(const PObject & obj) const
  4419. {
  4420. #ifndef PASN_LEANANDMEAN
  4421.   PAssert(IsDescendant(GCC_ConferenceTimeExtendIndication::Class()), PInvalidCast);
  4422. #endif
  4423.   const GCC_ConferenceTimeExtendIndication & other = (const GCC_ConferenceTimeExtendIndication &)obj;
  4424.  
  4425.   Comparison result;
  4426.  
  4427.   if ((result = m_timeToExtend.Compare(other.m_timeToExtend)) != EqualTo)
  4428.     return result;
  4429.   if ((result = m_nodeSpecificTimeFlag.Compare(other.m_nodeSpecificTimeFlag)) != EqualTo)
  4430.     return result;
  4431.  
  4432.   return PASN_Sequence::Compare(other);
  4433. }
  4434.  
  4435.  
  4436. PINDEX GCC_ConferenceTimeExtendIndication::GetDataLength() const
  4437. {
  4438.   PINDEX length = 0;
  4439.   length += m_timeToExtend.GetObjectLength();
  4440.   length += m_nodeSpecificTimeFlag.GetObjectLength();
  4441.   return length;
  4442. }
  4443.  
  4444.  
  4445. BOOL GCC_ConferenceTimeExtendIndication::Decode(PASN_Stream & strm)
  4446. {
  4447.   if (!PreambleDecode(strm))
  4448.     return FALSE;
  4449.  
  4450.   if (!m_timeToExtend.Decode(strm))
  4451.     return FALSE;
  4452.   if (!m_nodeSpecificTimeFlag.Decode(strm))
  4453.     return FALSE;
  4454.  
  4455.   return UnknownExtensionsDecode(strm);
  4456. }
  4457.  
  4458.  
  4459. void GCC_ConferenceTimeExtendIndication::Encode(PASN_Stream & strm) const
  4460. {
  4461.   PreambleEncode(strm);
  4462.  
  4463.   m_timeToExtend.Encode(strm);
  4464.   m_nodeSpecificTimeFlag.Encode(strm);
  4465.  
  4466.   UnknownExtensionsEncode(strm);
  4467. }
  4468.  
  4469.  
  4470. PObject * GCC_ConferenceTimeExtendIndication::Clone() const
  4471. {
  4472. #ifndef PASN_LEANANDMEAN
  4473.   PAssert(IsClass(GCC_ConferenceTimeExtendIndication::Class()), PInvalidCast);
  4474. #endif
  4475.   return new GCC_ConferenceTimeExtendIndication(*this);
  4476. }
  4477.  
  4478.  
  4479. //
  4480. // ConferenceAssistanceIndication
  4481. //
  4482.  
  4483. GCC_ConferenceAssistanceIndication::GCC_ConferenceAssistanceIndication(unsigned tag, PASN_Object::TagClass tagClass)
  4484.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  4485. {
  4486. }
  4487.  
  4488.  
  4489. #ifndef PASN_NOPRINTON
  4490. void GCC_ConferenceAssistanceIndication::PrintOn(ostream & strm) const
  4491. {
  4492.   int indent = strm.precision() + 2;
  4493.   strm << "{\n";
  4494.   if (HasOptionalField(e_userData))
  4495.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  4496.   strm << setw(indent-1) << "}";
  4497. }
  4498. #endif
  4499.  
  4500.  
  4501. PObject::Comparison GCC_ConferenceAssistanceIndication::Compare(const PObject & obj) const
  4502. {
  4503. #ifndef PASN_LEANANDMEAN
  4504.   PAssert(IsDescendant(GCC_ConferenceAssistanceIndication::Class()), PInvalidCast);
  4505. #endif
  4506.   const GCC_ConferenceAssistanceIndication & other = (const GCC_ConferenceAssistanceIndication &)obj;
  4507.  
  4508.   Comparison result;
  4509.  
  4510.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  4511.     return result;
  4512.  
  4513.   return PASN_Sequence::Compare(other);
  4514. }
  4515.  
  4516.  
  4517. PINDEX GCC_ConferenceAssistanceIndication::GetDataLength() const
  4518. {
  4519.   PINDEX length = 0;
  4520.   if (HasOptionalField(e_userData))
  4521.     length += m_userData.GetObjectLength();
  4522.   return length;
  4523. }
  4524.  
  4525.  
  4526. BOOL GCC_ConferenceAssistanceIndication::Decode(PASN_Stream & strm)
  4527. {
  4528.   if (!PreambleDecode(strm))
  4529.     return FALSE;
  4530.  
  4531.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  4532.     return FALSE;
  4533.  
  4534.   return UnknownExtensionsDecode(strm);
  4535. }
  4536.  
  4537.  
  4538. void GCC_ConferenceAssistanceIndication::Encode(PASN_Stream & strm) const
  4539. {
  4540.   PreambleEncode(strm);
  4541.  
  4542.   if (HasOptionalField(e_userData))
  4543.     m_userData.Encode(strm);
  4544.  
  4545.   UnknownExtensionsEncode(strm);
  4546. }
  4547.  
  4548.  
  4549. PObject * GCC_ConferenceAssistanceIndication::Clone() const
  4550. {
  4551. #ifndef PASN_LEANANDMEAN
  4552.   PAssert(IsClass(GCC_ConferenceAssistanceIndication::Class()), PInvalidCast);
  4553. #endif
  4554.   return new GCC_ConferenceAssistanceIndication(*this);
  4555. }
  4556.  
  4557.  
  4558. //
  4559. // TextMessageIndication
  4560. //
  4561.  
  4562. GCC_TextMessageIndication::GCC_TextMessageIndication(unsigned tag, PASN_Object::TagClass tagClass)
  4563.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  4564. {
  4565. }
  4566.  
  4567.  
  4568. #ifndef PASN_NOPRINTON
  4569. void GCC_TextMessageIndication::PrintOn(ostream & strm) const
  4570. {
  4571.   int indent = strm.precision() + 2;
  4572.   strm << "{\n";
  4573.   strm << setw(indent+10) << "message = " << setprecision(indent) << m_message << '\n';
  4574.   strm << setw(indent-1) << "}";
  4575. }
  4576. #endif
  4577.  
  4578.  
  4579. PObject::Comparison GCC_TextMessageIndication::Compare(const PObject & obj) const
  4580. {
  4581. #ifndef PASN_LEANANDMEAN
  4582.   PAssert(IsDescendant(GCC_TextMessageIndication::Class()), PInvalidCast);
  4583. #endif
  4584.   const GCC_TextMessageIndication & other = (const GCC_TextMessageIndication &)obj;
  4585.  
  4586.   Comparison result;
  4587.  
  4588.   if ((result = m_message.Compare(other.m_message)) != EqualTo)
  4589.     return result;
  4590.  
  4591.   return PASN_Sequence::Compare(other);
  4592. }
  4593.  
  4594.  
  4595. PINDEX GCC_TextMessageIndication::GetDataLength() const
  4596. {
  4597.   PINDEX length = 0;
  4598.   length += m_message.GetObjectLength();
  4599.   return length;
  4600. }
  4601.  
  4602.  
  4603. BOOL GCC_TextMessageIndication::Decode(PASN_Stream & strm)
  4604. {
  4605.   if (!PreambleDecode(strm))
  4606.     return FALSE;
  4607.  
  4608.   if (!m_message.Decode(strm))
  4609.     return FALSE;
  4610.  
  4611.   return UnknownExtensionsDecode(strm);
  4612. }
  4613.  
  4614.  
  4615. void GCC_TextMessageIndication::Encode(PASN_Stream & strm) const
  4616. {
  4617.   PreambleEncode(strm);
  4618.  
  4619.   m_message.Encode(strm);
  4620.  
  4621.   UnknownExtensionsEncode(strm);
  4622. }
  4623.  
  4624.  
  4625. PObject * GCC_TextMessageIndication::Clone() const
  4626. {
  4627. #ifndef PASN_LEANANDMEAN
  4628.   PAssert(IsClass(GCC_TextMessageIndication::Class()), PInvalidCast);
  4629. #endif
  4630.   return new GCC_TextMessageIndication(*this);
  4631. }
  4632.  
  4633.  
  4634. //
  4635. // NonStandardPDU
  4636. //
  4637.  
  4638. GCC_NonStandardPDU::GCC_NonStandardPDU(unsigned tag, PASN_Object::TagClass tagClass)
  4639.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  4640. {
  4641. }
  4642.  
  4643.  
  4644. #ifndef PASN_NOPRINTON
  4645. void GCC_NonStandardPDU::PrintOn(ostream & strm) const
  4646. {
  4647.   int indent = strm.precision() + 2;
  4648.   strm << "{\n";
  4649.   strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
  4650.   strm << setw(indent-1) << "}";
  4651. }
  4652. #endif
  4653.  
  4654.  
  4655. PObject::Comparison GCC_NonStandardPDU::Compare(const PObject & obj) const
  4656. {
  4657. #ifndef PASN_LEANANDMEAN
  4658.   PAssert(IsDescendant(GCC_NonStandardPDU::Class()), PInvalidCast);
  4659. #endif
  4660.   const GCC_NonStandardPDU & other = (const GCC_NonStandardPDU &)obj;
  4661.  
  4662.   Comparison result;
  4663.  
  4664.   if ((result = m_data.Compare(other.m_data)) != EqualTo)
  4665.     return result;
  4666.  
  4667.   return PASN_Sequence::Compare(other);
  4668. }
  4669.  
  4670.  
  4671. PINDEX GCC_NonStandardPDU::GetDataLength() const
  4672. {
  4673.   PINDEX length = 0;
  4674.   length += m_data.GetObjectLength();
  4675.   return length;
  4676. }
  4677.  
  4678.  
  4679. BOOL GCC_NonStandardPDU::Decode(PASN_Stream & strm)
  4680. {
  4681.   if (!PreambleDecode(strm))
  4682.     return FALSE;
  4683.  
  4684.   if (!m_data.Decode(strm))
  4685.     return FALSE;
  4686.  
  4687.   return UnknownExtensionsDecode(strm);
  4688. }
  4689.  
  4690.  
  4691. void GCC_NonStandardPDU::Encode(PASN_Stream & strm) const
  4692. {
  4693.   PreambleEncode(strm);
  4694.  
  4695.   m_data.Encode(strm);
  4696.  
  4697.   UnknownExtensionsEncode(strm);
  4698. }
  4699.  
  4700.  
  4701. PObject * GCC_NonStandardPDU::Clone() const
  4702. {
  4703. #ifndef PASN_LEANANDMEAN
  4704.   PAssert(IsClass(GCC_NonStandardPDU::Class()), PInvalidCast);
  4705. #endif
  4706.   return new GCC_NonStandardPDU(*this);
  4707. }
  4708.  
  4709.  
  4710. //
  4711. // ConnectData
  4712. //
  4713.  
  4714. GCC_ConnectData::GCC_ConnectData(unsigned tag, PASN_Object::TagClass tagClass)
  4715.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  4716. {
  4717. }
  4718.  
  4719.  
  4720. #ifndef PASN_NOPRINTON
  4721. void GCC_ConnectData::PrintOn(ostream & strm) const
  4722. {
  4723.   int indent = strm.precision() + 2;
  4724.   strm << "{\n";
  4725.   strm << setw(indent+17) << "t124Identifier = " << setprecision(indent) << m_t124Identifier << '\n';
  4726.   strm << setw(indent+13) << "connectPDU = " << setprecision(indent) << m_connectPDU << '\n';
  4727.   strm << setw(indent-1) << "}";
  4728. }
  4729. #endif
  4730.  
  4731.  
  4732. PObject::Comparison GCC_ConnectData::Compare(const PObject & obj) const
  4733. {
  4734. #ifndef PASN_LEANANDMEAN
  4735.   PAssert(IsDescendant(GCC_ConnectData::Class()), PInvalidCast);
  4736. #endif
  4737.   const GCC_ConnectData & other = (const GCC_ConnectData &)obj;
  4738.  
  4739.   Comparison result;
  4740.  
  4741.   if ((result = m_t124Identifier.Compare(other.m_t124Identifier)) != EqualTo)
  4742.     return result;
  4743.   if ((result = m_connectPDU.Compare(other.m_connectPDU)) != EqualTo)
  4744.     return result;
  4745.  
  4746.   return PASN_Sequence::Compare(other);
  4747. }
  4748.  
  4749.  
  4750. PINDEX GCC_ConnectData::GetDataLength() const
  4751. {
  4752.   PINDEX length = 0;
  4753.   length += m_t124Identifier.GetObjectLength();
  4754.   length += m_connectPDU.GetObjectLength();
  4755.   return length;
  4756. }
  4757.  
  4758.  
  4759. BOOL GCC_ConnectData::Decode(PASN_Stream & strm)
  4760. {
  4761.   if (!PreambleDecode(strm))
  4762.     return FALSE;
  4763.  
  4764.   if (!m_t124Identifier.Decode(strm))
  4765.     return FALSE;
  4766.   if (!m_connectPDU.Decode(strm))
  4767.     return FALSE;
  4768.  
  4769.   return UnknownExtensionsDecode(strm);
  4770. }
  4771.  
  4772.  
  4773. void GCC_ConnectData::Encode(PASN_Stream & strm) const
  4774. {
  4775.   PreambleEncode(strm);
  4776.  
  4777.   m_t124Identifier.Encode(strm);
  4778.   m_connectPDU.Encode(strm);
  4779.  
  4780.   UnknownExtensionsEncode(strm);
  4781. }
  4782.  
  4783.  
  4784. PObject * GCC_ConnectData::Clone() const
  4785. {
  4786. #ifndef PASN_LEANANDMEAN
  4787.   PAssert(IsClass(GCC_ConnectData::Class()), PInvalidCast);
  4788. #endif
  4789.   return new GCC_ConnectData(*this);
  4790. }
  4791.  
  4792.  
  4793. //
  4794. // ConnectGCCPDU
  4795. //
  4796.  
  4797. GCC_ConnectGCCPDU::GCC_ConnectGCCPDU(unsigned tag, PASN_Object::TagClass tagClass)
  4798.   : PASN_Choice(tag, tagClass, 8, TRUE
  4799. #ifndef PASN_NOPRINTON
  4800.       , "conferenceCreateRequest "
  4801.         "conferenceCreateResponse "
  4802.         "conferenceQueryRequest "
  4803.         "conferenceQueryResponse "
  4804.         "conferenceJoinRequest "
  4805.         "conferenceJoinResponse "
  4806.         "conferenceInviteRequest "
  4807.         "conferenceInviteResponse "
  4808. #endif
  4809.     )
  4810. {
  4811. }
  4812.  
  4813.  
  4814. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  4815. GCC_ConnectGCCPDU::operator GCC_ConferenceCreateRequest &() const
  4816. #else
  4817. GCC_ConnectGCCPDU::operator GCC_ConferenceCreateRequest &()
  4818. {
  4819. #ifndef PASN_LEANANDMEAN
  4820.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceCreateRequest::Class()), PInvalidCast);
  4821. #endif
  4822.   return *(GCC_ConferenceCreateRequest *)choice;
  4823. }
  4824.  
  4825.  
  4826. GCC_ConnectGCCPDU::operator const GCC_ConferenceCreateRequest &() const
  4827. #endif
  4828. {
  4829. #ifndef PASN_LEANANDMEAN
  4830.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceCreateRequest::Class()), PInvalidCast);
  4831. #endif
  4832.   return *(GCC_ConferenceCreateRequest *)choice;
  4833. }
  4834.  
  4835.  
  4836. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  4837. GCC_ConnectGCCPDU::operator GCC_ConferenceCreateResponse &() const
  4838. #else
  4839. GCC_ConnectGCCPDU::operator GCC_ConferenceCreateResponse &()
  4840. {
  4841. #ifndef PASN_LEANANDMEAN
  4842.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceCreateResponse::Class()), PInvalidCast);
  4843. #endif
  4844.   return *(GCC_ConferenceCreateResponse *)choice;
  4845. }
  4846.  
  4847.  
  4848. GCC_ConnectGCCPDU::operator const GCC_ConferenceCreateResponse &() const
  4849. #endif
  4850. {
  4851. #ifndef PASN_LEANANDMEAN
  4852.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceCreateResponse::Class()), PInvalidCast);
  4853. #endif
  4854.   return *(GCC_ConferenceCreateResponse *)choice;
  4855. }
  4856.  
  4857.  
  4858. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  4859. GCC_ConnectGCCPDU::operator GCC_ConferenceQueryRequest &() const
  4860. #else
  4861. GCC_ConnectGCCPDU::operator GCC_ConferenceQueryRequest &()
  4862. {
  4863. #ifndef PASN_LEANANDMEAN
  4864.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceQueryRequest::Class()), PInvalidCast);
  4865. #endif
  4866.   return *(GCC_ConferenceQueryRequest *)choice;
  4867. }
  4868.  
  4869.  
  4870. GCC_ConnectGCCPDU::operator const GCC_ConferenceQueryRequest &() const
  4871. #endif
  4872. {
  4873. #ifndef PASN_LEANANDMEAN
  4874.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceQueryRequest::Class()), PInvalidCast);
  4875. #endif
  4876.   return *(GCC_ConferenceQueryRequest *)choice;
  4877. }
  4878.  
  4879.  
  4880. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  4881. GCC_ConnectGCCPDU::operator GCC_ConferenceQueryResponse &() const
  4882. #else
  4883. GCC_ConnectGCCPDU::operator GCC_ConferenceQueryResponse &()
  4884. {
  4885. #ifndef PASN_LEANANDMEAN
  4886.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceQueryResponse::Class()), PInvalidCast);
  4887. #endif
  4888.   return *(GCC_ConferenceQueryResponse *)choice;
  4889. }
  4890.  
  4891.  
  4892. GCC_ConnectGCCPDU::operator const GCC_ConferenceQueryResponse &() const
  4893. #endif
  4894. {
  4895. #ifndef PASN_LEANANDMEAN
  4896.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceQueryResponse::Class()), PInvalidCast);
  4897. #endif
  4898.   return *(GCC_ConferenceQueryResponse *)choice;
  4899. }
  4900.  
  4901.  
  4902. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  4903. GCC_ConnectGCCPDU::operator GCC_ConferenceJoinRequest &() const
  4904. #else
  4905. GCC_ConnectGCCPDU::operator GCC_ConferenceJoinRequest &()
  4906. {
  4907. #ifndef PASN_LEANANDMEAN
  4908.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceJoinRequest::Class()), PInvalidCast);
  4909. #endif
  4910.   return *(GCC_ConferenceJoinRequest *)choice;
  4911. }
  4912.  
  4913.  
  4914. GCC_ConnectGCCPDU::operator const GCC_ConferenceJoinRequest &() const
  4915. #endif
  4916. {
  4917. #ifndef PASN_LEANANDMEAN
  4918.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceJoinRequest::Class()), PInvalidCast);
  4919. #endif
  4920.   return *(GCC_ConferenceJoinRequest *)choice;
  4921. }
  4922.  
  4923.  
  4924. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  4925. GCC_ConnectGCCPDU::operator GCC_ConferenceJoinResponse &() const
  4926. #else
  4927. GCC_ConnectGCCPDU::operator GCC_ConferenceJoinResponse &()
  4928. {
  4929. #ifndef PASN_LEANANDMEAN
  4930.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceJoinResponse::Class()), PInvalidCast);
  4931. #endif
  4932.   return *(GCC_ConferenceJoinResponse *)choice;
  4933. }
  4934.  
  4935.  
  4936. GCC_ConnectGCCPDU::operator const GCC_ConferenceJoinResponse &() const
  4937. #endif
  4938. {
  4939. #ifndef PASN_LEANANDMEAN
  4940.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceJoinResponse::Class()), PInvalidCast);
  4941. #endif
  4942.   return *(GCC_ConferenceJoinResponse *)choice;
  4943. }
  4944.  
  4945.  
  4946. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  4947. GCC_ConnectGCCPDU::operator GCC_ConferenceInviteRequest &() const
  4948. #else
  4949. GCC_ConnectGCCPDU::operator GCC_ConferenceInviteRequest &()
  4950. {
  4951. #ifndef PASN_LEANANDMEAN
  4952.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceInviteRequest::Class()), PInvalidCast);
  4953. #endif
  4954.   return *(GCC_ConferenceInviteRequest *)choice;
  4955. }
  4956.  
  4957.  
  4958. GCC_ConnectGCCPDU::operator const GCC_ConferenceInviteRequest &() const
  4959. #endif
  4960. {
  4961. #ifndef PASN_LEANANDMEAN
  4962.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceInviteRequest::Class()), PInvalidCast);
  4963. #endif
  4964.   return *(GCC_ConferenceInviteRequest *)choice;
  4965. }
  4966.  
  4967.  
  4968. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  4969. GCC_ConnectGCCPDU::operator GCC_ConferenceInviteResponse &() const
  4970. #else
  4971. GCC_ConnectGCCPDU::operator GCC_ConferenceInviteResponse &()
  4972. {
  4973. #ifndef PASN_LEANANDMEAN
  4974.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceInviteResponse::Class()), PInvalidCast);
  4975. #endif
  4976.   return *(GCC_ConferenceInviteResponse *)choice;
  4977. }
  4978.  
  4979.  
  4980. GCC_ConnectGCCPDU::operator const GCC_ConferenceInviteResponse &() const
  4981. #endif
  4982. {
  4983. #ifndef PASN_LEANANDMEAN
  4984.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceInviteResponse::Class()), PInvalidCast);
  4985. #endif
  4986.   return *(GCC_ConferenceInviteResponse *)choice;
  4987. }
  4988.  
  4989.  
  4990. BOOL GCC_ConnectGCCPDU::CreateObject()
  4991. {
  4992.   switch (tag) {
  4993.     case e_conferenceCreateRequest :
  4994.       choice = new GCC_ConferenceCreateRequest();
  4995.       return TRUE;
  4996.     case e_conferenceCreateResponse :
  4997.       choice = new GCC_ConferenceCreateResponse();
  4998.       return TRUE;
  4999.     case e_conferenceQueryRequest :
  5000.       choice = new GCC_ConferenceQueryRequest();
  5001.       return TRUE;
  5002.     case e_conferenceQueryResponse :
  5003.       choice = new GCC_ConferenceQueryResponse();
  5004.       return TRUE;
  5005.     case e_conferenceJoinRequest :
  5006.       choice = new GCC_ConferenceJoinRequest();
  5007.       return TRUE;
  5008.     case e_conferenceJoinResponse :
  5009.       choice = new GCC_ConferenceJoinResponse();
  5010.       return TRUE;
  5011.     case e_conferenceInviteRequest :
  5012.       choice = new GCC_ConferenceInviteRequest();
  5013.       return TRUE;
  5014.     case e_conferenceInviteResponse :
  5015.       choice = new GCC_ConferenceInviteResponse();
  5016.       return TRUE;
  5017.   }
  5018.  
  5019.   choice = NULL;
  5020.   return FALSE;
  5021. }
  5022.  
  5023.  
  5024. PObject * GCC_ConnectGCCPDU::Clone() const
  5025. {
  5026. #ifndef PASN_LEANANDMEAN
  5027.   PAssert(IsClass(GCC_ConnectGCCPDU::Class()), PInvalidCast);
  5028. #endif
  5029.   return new GCC_ConnectGCCPDU(*this);
  5030. }
  5031.  
  5032.  
  5033. //
  5034. // GCCPDU
  5035. //
  5036.  
  5037. GCC_GCCPDU::GCC_GCCPDU(unsigned tag, PASN_Object::TagClass tagClass)
  5038.   : PASN_Choice(tag, tagClass, 3, FALSE
  5039. #ifndef PASN_NOPRINTON
  5040.       , "request "
  5041.         "response "
  5042.         "indication "
  5043. #endif
  5044.     )
  5045. {
  5046. }
  5047.  
  5048.  
  5049. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5050. GCC_GCCPDU::operator GCC_RequestPDU &() const
  5051. #else
  5052. GCC_GCCPDU::operator GCC_RequestPDU &()
  5053. {
  5054. #ifndef PASN_LEANANDMEAN
  5055.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RequestPDU::Class()), PInvalidCast);
  5056. #endif
  5057.   return *(GCC_RequestPDU *)choice;
  5058. }
  5059.  
  5060.  
  5061. GCC_GCCPDU::operator const GCC_RequestPDU &() const
  5062. #endif
  5063. {
  5064. #ifndef PASN_LEANANDMEAN
  5065.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RequestPDU::Class()), PInvalidCast);
  5066. #endif
  5067.   return *(GCC_RequestPDU *)choice;
  5068. }
  5069.  
  5070.  
  5071. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5072. GCC_GCCPDU::operator GCC_ResponsePDU &() const
  5073. #else
  5074. GCC_GCCPDU::operator GCC_ResponsePDU &()
  5075. {
  5076. #ifndef PASN_LEANANDMEAN
  5077.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ResponsePDU::Class()), PInvalidCast);
  5078. #endif
  5079.   return *(GCC_ResponsePDU *)choice;
  5080. }
  5081.  
  5082.  
  5083. GCC_GCCPDU::operator const GCC_ResponsePDU &() const
  5084. #endif
  5085. {
  5086. #ifndef PASN_LEANANDMEAN
  5087.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ResponsePDU::Class()), PInvalidCast);
  5088. #endif
  5089.   return *(GCC_ResponsePDU *)choice;
  5090. }
  5091.  
  5092.  
  5093. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5094. GCC_GCCPDU::operator GCC_IndicationPDU &() const
  5095. #else
  5096. GCC_GCCPDU::operator GCC_IndicationPDU &()
  5097. {
  5098. #ifndef PASN_LEANANDMEAN
  5099.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_IndicationPDU::Class()), PInvalidCast);
  5100. #endif
  5101.   return *(GCC_IndicationPDU *)choice;
  5102. }
  5103.  
  5104.  
  5105. GCC_GCCPDU::operator const GCC_IndicationPDU &() const
  5106. #endif
  5107. {
  5108. #ifndef PASN_LEANANDMEAN
  5109.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_IndicationPDU::Class()), PInvalidCast);
  5110. #endif
  5111.   return *(GCC_IndicationPDU *)choice;
  5112. }
  5113.  
  5114.  
  5115. BOOL GCC_GCCPDU::CreateObject()
  5116. {
  5117.   switch (tag) {
  5118.     case e_request :
  5119.       choice = new GCC_RequestPDU();
  5120.       return TRUE;
  5121.     case e_response :
  5122.       choice = new GCC_ResponsePDU();
  5123.       return TRUE;
  5124.     case e_indication :
  5125.       choice = new GCC_IndicationPDU();
  5126.       return TRUE;
  5127.   }
  5128.  
  5129.   choice = NULL;
  5130.   return FALSE;
  5131. }
  5132.  
  5133.  
  5134. PObject * GCC_GCCPDU::Clone() const
  5135. {
  5136. #ifndef PASN_LEANANDMEAN
  5137.   PAssert(IsClass(GCC_GCCPDU::Class()), PInvalidCast);
  5138. #endif
  5139.   return new GCC_GCCPDU(*this);
  5140. }
  5141.  
  5142.  
  5143. //
  5144. // RequestPDU
  5145. //
  5146.  
  5147. GCC_RequestPDU::GCC_RequestPDU(unsigned tag, PASN_Object::TagClass tagClass)
  5148.   : PASN_Choice(tag, tagClass, 15, TRUE
  5149. #ifndef PASN_NOPRINTON
  5150.       , "conferenceJoinRequest "
  5151.         "conferenceAddRequest "
  5152.         "conferenceLockRequest "
  5153.         "conferenceUnlockRequest "
  5154.         "conferenceTerminateRequest "
  5155.         "conferenceEjectUserRequest "
  5156.         "conferenceTransferRequest "
  5157.         "registryRegisterChannelRequest "
  5158.         "registryAssignTokenRequest "
  5159.         "registrySetParameterRequest "
  5160.         "registryRetrieveEntryRequest "
  5161.         "registryDeleteEntryRequest "
  5162.         "registryMonitorEntryRequest "
  5163.         "registryAllocateHandleRequest "
  5164.         "nonStandardRequest "
  5165. #endif
  5166.     )
  5167. {
  5168. }
  5169.  
  5170.  
  5171. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5172. GCC_RequestPDU::operator GCC_ConferenceJoinRequest &() const
  5173. #else
  5174. GCC_RequestPDU::operator GCC_ConferenceJoinRequest &()
  5175. {
  5176. #ifndef PASN_LEANANDMEAN
  5177.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceJoinRequest::Class()), PInvalidCast);
  5178. #endif
  5179.   return *(GCC_ConferenceJoinRequest *)choice;
  5180. }
  5181.  
  5182.  
  5183. GCC_RequestPDU::operator const GCC_ConferenceJoinRequest &() const
  5184. #endif
  5185. {
  5186. #ifndef PASN_LEANANDMEAN
  5187.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceJoinRequest::Class()), PInvalidCast);
  5188. #endif
  5189.   return *(GCC_ConferenceJoinRequest *)choice;
  5190. }
  5191.  
  5192.  
  5193. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5194. GCC_RequestPDU::operator GCC_ConferenceAddRequest &() const
  5195. #else
  5196. GCC_RequestPDU::operator GCC_ConferenceAddRequest &()
  5197. {
  5198. #ifndef PASN_LEANANDMEAN
  5199.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceAddRequest::Class()), PInvalidCast);
  5200. #endif
  5201.   return *(GCC_ConferenceAddRequest *)choice;
  5202. }
  5203.  
  5204.  
  5205. GCC_RequestPDU::operator const GCC_ConferenceAddRequest &() const
  5206. #endif
  5207. {
  5208. #ifndef PASN_LEANANDMEAN
  5209.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceAddRequest::Class()), PInvalidCast);
  5210. #endif
  5211.   return *(GCC_ConferenceAddRequest *)choice;
  5212. }
  5213.  
  5214.  
  5215. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5216. GCC_RequestPDU::operator GCC_ConferenceLockRequest &() const
  5217. #else
  5218. GCC_RequestPDU::operator GCC_ConferenceLockRequest &()
  5219. {
  5220. #ifndef PASN_LEANANDMEAN
  5221.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceLockRequest::Class()), PInvalidCast);
  5222. #endif
  5223.   return *(GCC_ConferenceLockRequest *)choice;
  5224. }
  5225.  
  5226.  
  5227. GCC_RequestPDU::operator const GCC_ConferenceLockRequest &() const
  5228. #endif
  5229. {
  5230. #ifndef PASN_LEANANDMEAN
  5231.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceLockRequest::Class()), PInvalidCast);
  5232. #endif
  5233.   return *(GCC_ConferenceLockRequest *)choice;
  5234. }
  5235.  
  5236.  
  5237. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5238. GCC_RequestPDU::operator GCC_ConferenceUnlockRequest &() const
  5239. #else
  5240. GCC_RequestPDU::operator GCC_ConferenceUnlockRequest &()
  5241. {
  5242. #ifndef PASN_LEANANDMEAN
  5243.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceUnlockRequest::Class()), PInvalidCast);
  5244. #endif
  5245.   return *(GCC_ConferenceUnlockRequest *)choice;
  5246. }
  5247.  
  5248.  
  5249. GCC_RequestPDU::operator const GCC_ConferenceUnlockRequest &() const
  5250. #endif
  5251. {
  5252. #ifndef PASN_LEANANDMEAN
  5253.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceUnlockRequest::Class()), PInvalidCast);
  5254. #endif
  5255.   return *(GCC_ConferenceUnlockRequest *)choice;
  5256. }
  5257.  
  5258.  
  5259. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5260. GCC_RequestPDU::operator GCC_ConferenceTerminateRequest &() const
  5261. #else
  5262. GCC_RequestPDU::operator GCC_ConferenceTerminateRequest &()
  5263. {
  5264. #ifndef PASN_LEANANDMEAN
  5265.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTerminateRequest::Class()), PInvalidCast);
  5266. #endif
  5267.   return *(GCC_ConferenceTerminateRequest *)choice;
  5268. }
  5269.  
  5270.  
  5271. GCC_RequestPDU::operator const GCC_ConferenceTerminateRequest &() const
  5272. #endif
  5273. {
  5274. #ifndef PASN_LEANANDMEAN
  5275.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTerminateRequest::Class()), PInvalidCast);
  5276. #endif
  5277.   return *(GCC_ConferenceTerminateRequest *)choice;
  5278. }
  5279.  
  5280.  
  5281. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5282. GCC_RequestPDU::operator GCC_ConferenceEjectUserRequest &() const
  5283. #else
  5284. GCC_RequestPDU::operator GCC_ConferenceEjectUserRequest &()
  5285. {
  5286. #ifndef PASN_LEANANDMEAN
  5287.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceEjectUserRequest::Class()), PInvalidCast);
  5288. #endif
  5289.   return *(GCC_ConferenceEjectUserRequest *)choice;
  5290. }
  5291.  
  5292.  
  5293. GCC_RequestPDU::operator const GCC_ConferenceEjectUserRequest &() const
  5294. #endif
  5295. {
  5296. #ifndef PASN_LEANANDMEAN
  5297.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceEjectUserRequest::Class()), PInvalidCast);
  5298. #endif
  5299.   return *(GCC_ConferenceEjectUserRequest *)choice;
  5300. }
  5301.  
  5302.  
  5303. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5304. GCC_RequestPDU::operator GCC_ConferenceTransferRequest &() const
  5305. #else
  5306. GCC_RequestPDU::operator GCC_ConferenceTransferRequest &()
  5307. {
  5308. #ifndef PASN_LEANANDMEAN
  5309.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTransferRequest::Class()), PInvalidCast);
  5310. #endif
  5311.   return *(GCC_ConferenceTransferRequest *)choice;
  5312. }
  5313.  
  5314.  
  5315. GCC_RequestPDU::operator const GCC_ConferenceTransferRequest &() const
  5316. #endif
  5317. {
  5318. #ifndef PASN_LEANANDMEAN
  5319.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTransferRequest::Class()), PInvalidCast);
  5320. #endif
  5321.   return *(GCC_ConferenceTransferRequest *)choice;
  5322. }
  5323.  
  5324.  
  5325. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5326. GCC_RequestPDU::operator GCC_RegistryRegisterChannelRequest &() const
  5327. #else
  5328. GCC_RequestPDU::operator GCC_RegistryRegisterChannelRequest &()
  5329. {
  5330. #ifndef PASN_LEANANDMEAN
  5331.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryRegisterChannelRequest::Class()), PInvalidCast);
  5332. #endif
  5333.   return *(GCC_RegistryRegisterChannelRequest *)choice;
  5334. }
  5335.  
  5336.  
  5337. GCC_RequestPDU::operator const GCC_RegistryRegisterChannelRequest &() const
  5338. #endif
  5339. {
  5340. #ifndef PASN_LEANANDMEAN
  5341.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryRegisterChannelRequest::Class()), PInvalidCast);
  5342. #endif
  5343.   return *(GCC_RegistryRegisterChannelRequest *)choice;
  5344. }
  5345.  
  5346.  
  5347. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5348. GCC_RequestPDU::operator GCC_RegistryAssignTokenRequest &() const
  5349. #else
  5350. GCC_RequestPDU::operator GCC_RegistryAssignTokenRequest &()
  5351. {
  5352. #ifndef PASN_LEANANDMEAN
  5353.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryAssignTokenRequest::Class()), PInvalidCast);
  5354. #endif
  5355.   return *(GCC_RegistryAssignTokenRequest *)choice;
  5356. }
  5357.  
  5358.  
  5359. GCC_RequestPDU::operator const GCC_RegistryAssignTokenRequest &() const
  5360. #endif
  5361. {
  5362. #ifndef PASN_LEANANDMEAN
  5363.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryAssignTokenRequest::Class()), PInvalidCast);
  5364. #endif
  5365.   return *(GCC_RegistryAssignTokenRequest *)choice;
  5366. }
  5367.  
  5368.  
  5369. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5370. GCC_RequestPDU::operator GCC_RegistrySetParameterRequest &() const
  5371. #else
  5372. GCC_RequestPDU::operator GCC_RegistrySetParameterRequest &()
  5373. {
  5374. #ifndef PASN_LEANANDMEAN
  5375.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistrySetParameterRequest::Class()), PInvalidCast);
  5376. #endif
  5377.   return *(GCC_RegistrySetParameterRequest *)choice;
  5378. }
  5379.  
  5380.  
  5381. GCC_RequestPDU::operator const GCC_RegistrySetParameterRequest &() const
  5382. #endif
  5383. {
  5384. #ifndef PASN_LEANANDMEAN
  5385.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistrySetParameterRequest::Class()), PInvalidCast);
  5386. #endif
  5387.   return *(GCC_RegistrySetParameterRequest *)choice;
  5388. }
  5389.  
  5390.  
  5391. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5392. GCC_RequestPDU::operator GCC_RegistryRetrieveEntryRequest &() const
  5393. #else
  5394. GCC_RequestPDU::operator GCC_RegistryRetrieveEntryRequest &()
  5395. {
  5396. #ifndef PASN_LEANANDMEAN
  5397.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryRetrieveEntryRequest::Class()), PInvalidCast);
  5398. #endif
  5399.   return *(GCC_RegistryRetrieveEntryRequest *)choice;
  5400. }
  5401.  
  5402.  
  5403. GCC_RequestPDU::operator const GCC_RegistryRetrieveEntryRequest &() const
  5404. #endif
  5405. {
  5406. #ifndef PASN_LEANANDMEAN
  5407.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryRetrieveEntryRequest::Class()), PInvalidCast);
  5408. #endif
  5409.   return *(GCC_RegistryRetrieveEntryRequest *)choice;
  5410. }
  5411.  
  5412.  
  5413. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5414. GCC_RequestPDU::operator GCC_RegistryDeleteEntryRequest &() const
  5415. #else
  5416. GCC_RequestPDU::operator GCC_RegistryDeleteEntryRequest &()
  5417. {
  5418. #ifndef PASN_LEANANDMEAN
  5419.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryDeleteEntryRequest::Class()), PInvalidCast);
  5420. #endif
  5421.   return *(GCC_RegistryDeleteEntryRequest *)choice;
  5422. }
  5423.  
  5424.  
  5425. GCC_RequestPDU::operator const GCC_RegistryDeleteEntryRequest &() const
  5426. #endif
  5427. {
  5428. #ifndef PASN_LEANANDMEAN
  5429.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryDeleteEntryRequest::Class()), PInvalidCast);
  5430. #endif
  5431.   return *(GCC_RegistryDeleteEntryRequest *)choice;
  5432. }
  5433.  
  5434.  
  5435. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5436. GCC_RequestPDU::operator GCC_RegistryMonitorEntryRequest &() const
  5437. #else
  5438. GCC_RequestPDU::operator GCC_RegistryMonitorEntryRequest &()
  5439. {
  5440. #ifndef PASN_LEANANDMEAN
  5441.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryMonitorEntryRequest::Class()), PInvalidCast);
  5442. #endif
  5443.   return *(GCC_RegistryMonitorEntryRequest *)choice;
  5444. }
  5445.  
  5446.  
  5447. GCC_RequestPDU::operator const GCC_RegistryMonitorEntryRequest &() const
  5448. #endif
  5449. {
  5450. #ifndef PASN_LEANANDMEAN
  5451.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryMonitorEntryRequest::Class()), PInvalidCast);
  5452. #endif
  5453.   return *(GCC_RegistryMonitorEntryRequest *)choice;
  5454. }
  5455.  
  5456.  
  5457. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5458. GCC_RequestPDU::operator GCC_RegistryAllocateHandleRequest &() const
  5459. #else
  5460. GCC_RequestPDU::operator GCC_RegistryAllocateHandleRequest &()
  5461. {
  5462. #ifndef PASN_LEANANDMEAN
  5463.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryAllocateHandleRequest::Class()), PInvalidCast);
  5464. #endif
  5465.   return *(GCC_RegistryAllocateHandleRequest *)choice;
  5466. }
  5467.  
  5468.  
  5469. GCC_RequestPDU::operator const GCC_RegistryAllocateHandleRequest &() const
  5470. #endif
  5471. {
  5472. #ifndef PASN_LEANANDMEAN
  5473.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryAllocateHandleRequest::Class()), PInvalidCast);
  5474. #endif
  5475.   return *(GCC_RegistryAllocateHandleRequest *)choice;
  5476. }
  5477.  
  5478.  
  5479. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5480. GCC_RequestPDU::operator GCC_NonStandardPDU &() const
  5481. #else
  5482. GCC_RequestPDU::operator GCC_NonStandardPDU &()
  5483. {
  5484. #ifndef PASN_LEANANDMEAN
  5485.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardPDU::Class()), PInvalidCast);
  5486. #endif
  5487.   return *(GCC_NonStandardPDU *)choice;
  5488. }
  5489.  
  5490.  
  5491. GCC_RequestPDU::operator const GCC_NonStandardPDU &() const
  5492. #endif
  5493. {
  5494. #ifndef PASN_LEANANDMEAN
  5495.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardPDU::Class()), PInvalidCast);
  5496. #endif
  5497.   return *(GCC_NonStandardPDU *)choice;
  5498. }
  5499.  
  5500.  
  5501. BOOL GCC_RequestPDU::CreateObject()
  5502. {
  5503.   switch (tag) {
  5504.     case e_conferenceJoinRequest :
  5505.       choice = new GCC_ConferenceJoinRequest();
  5506.       return TRUE;
  5507.     case e_conferenceAddRequest :
  5508.       choice = new GCC_ConferenceAddRequest();
  5509.       return TRUE;
  5510.     case e_conferenceLockRequest :
  5511.       choice = new GCC_ConferenceLockRequest();
  5512.       return TRUE;
  5513.     case e_conferenceUnlockRequest :
  5514.       choice = new GCC_ConferenceUnlockRequest();
  5515.       return TRUE;
  5516.     case e_conferenceTerminateRequest :
  5517.       choice = new GCC_ConferenceTerminateRequest();
  5518.       return TRUE;
  5519.     case e_conferenceEjectUserRequest :
  5520.       choice = new GCC_ConferenceEjectUserRequest();
  5521.       return TRUE;
  5522.     case e_conferenceTransferRequest :
  5523.       choice = new GCC_ConferenceTransferRequest();
  5524.       return TRUE;
  5525.     case e_registryRegisterChannelRequest :
  5526.       choice = new GCC_RegistryRegisterChannelRequest();
  5527.       return TRUE;
  5528.     case e_registryAssignTokenRequest :
  5529.       choice = new GCC_RegistryAssignTokenRequest();
  5530.       return TRUE;
  5531.     case e_registrySetParameterRequest :
  5532.       choice = new GCC_RegistrySetParameterRequest();
  5533.       return TRUE;
  5534.     case e_registryRetrieveEntryRequest :
  5535.       choice = new GCC_RegistryRetrieveEntryRequest();
  5536.       return TRUE;
  5537.     case e_registryDeleteEntryRequest :
  5538.       choice = new GCC_RegistryDeleteEntryRequest();
  5539.       return TRUE;
  5540.     case e_registryMonitorEntryRequest :
  5541.       choice = new GCC_RegistryMonitorEntryRequest();
  5542.       return TRUE;
  5543.     case e_registryAllocateHandleRequest :
  5544.       choice = new GCC_RegistryAllocateHandleRequest();
  5545.       return TRUE;
  5546.     case e_nonStandardRequest :
  5547.       choice = new GCC_NonStandardPDU();
  5548.       return TRUE;
  5549.   }
  5550.  
  5551.   choice = NULL;
  5552.   return FALSE;
  5553. }
  5554.  
  5555.  
  5556. PObject * GCC_RequestPDU::Clone() const
  5557. {
  5558. #ifndef PASN_LEANANDMEAN
  5559.   PAssert(IsClass(GCC_RequestPDU::Class()), PInvalidCast);
  5560. #endif
  5561.   return new GCC_RequestPDU(*this);
  5562. }
  5563.  
  5564.  
  5565. //
  5566. // ResponsePDU
  5567. //
  5568.  
  5569. GCC_ResponsePDU::GCC_ResponsePDU(unsigned tag, PASN_Object::TagClass tagClass)
  5570.   : PASN_Choice(tag, tagClass, 11, TRUE
  5571. #ifndef PASN_NOPRINTON
  5572.       , "conferenceJoinResponse "
  5573.         "conferenceAddResponse "
  5574.         "conferenceLockResponse "
  5575.         "conferenceUnlockResponse "
  5576.         "conferenceTerminateResponse "
  5577.         "conferenceEjectUserResponse "
  5578.         "conferenceTransferResponse "
  5579.         "registryResponse "
  5580.         "registryAllocateHandleResponse "
  5581.         "functionNotSupportedResponse "
  5582.         "nonStandardResponse "
  5583. #endif
  5584.     )
  5585. {
  5586. }
  5587.  
  5588.  
  5589. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5590. GCC_ResponsePDU::operator GCC_ConferenceJoinResponse &() const
  5591. #else
  5592. GCC_ResponsePDU::operator GCC_ConferenceJoinResponse &()
  5593. {
  5594. #ifndef PASN_LEANANDMEAN
  5595.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceJoinResponse::Class()), PInvalidCast);
  5596. #endif
  5597.   return *(GCC_ConferenceJoinResponse *)choice;
  5598. }
  5599.  
  5600.  
  5601. GCC_ResponsePDU::operator const GCC_ConferenceJoinResponse &() const
  5602. #endif
  5603. {
  5604. #ifndef PASN_LEANANDMEAN
  5605.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceJoinResponse::Class()), PInvalidCast);
  5606. #endif
  5607.   return *(GCC_ConferenceJoinResponse *)choice;
  5608. }
  5609.  
  5610.  
  5611. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5612. GCC_ResponsePDU::operator GCC_ConferenceAddResponse &() const
  5613. #else
  5614. GCC_ResponsePDU::operator GCC_ConferenceAddResponse &()
  5615. {
  5616. #ifndef PASN_LEANANDMEAN
  5617.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceAddResponse::Class()), PInvalidCast);
  5618. #endif
  5619.   return *(GCC_ConferenceAddResponse *)choice;
  5620. }
  5621.  
  5622.  
  5623. GCC_ResponsePDU::operator const GCC_ConferenceAddResponse &() const
  5624. #endif
  5625. {
  5626. #ifndef PASN_LEANANDMEAN
  5627.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceAddResponse::Class()), PInvalidCast);
  5628. #endif
  5629.   return *(GCC_ConferenceAddResponse *)choice;
  5630. }
  5631.  
  5632.  
  5633. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5634. GCC_ResponsePDU::operator GCC_ConferenceLockResponse &() const
  5635. #else
  5636. GCC_ResponsePDU::operator GCC_ConferenceLockResponse &()
  5637. {
  5638. #ifndef PASN_LEANANDMEAN
  5639.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceLockResponse::Class()), PInvalidCast);
  5640. #endif
  5641.   return *(GCC_ConferenceLockResponse *)choice;
  5642. }
  5643.  
  5644.  
  5645. GCC_ResponsePDU::operator const GCC_ConferenceLockResponse &() const
  5646. #endif
  5647. {
  5648. #ifndef PASN_LEANANDMEAN
  5649.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceLockResponse::Class()), PInvalidCast);
  5650. #endif
  5651.   return *(GCC_ConferenceLockResponse *)choice;
  5652. }
  5653.  
  5654.  
  5655. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5656. GCC_ResponsePDU::operator GCC_ConferenceUnlockResponse &() const
  5657. #else
  5658. GCC_ResponsePDU::operator GCC_ConferenceUnlockResponse &()
  5659. {
  5660. #ifndef PASN_LEANANDMEAN
  5661.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceUnlockResponse::Class()), PInvalidCast);
  5662. #endif
  5663.   return *(GCC_ConferenceUnlockResponse *)choice;
  5664. }
  5665.  
  5666.  
  5667. GCC_ResponsePDU::operator const GCC_ConferenceUnlockResponse &() const
  5668. #endif
  5669. {
  5670. #ifndef PASN_LEANANDMEAN
  5671.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceUnlockResponse::Class()), PInvalidCast);
  5672. #endif
  5673.   return *(GCC_ConferenceUnlockResponse *)choice;
  5674. }
  5675.  
  5676.  
  5677. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5678. GCC_ResponsePDU::operator GCC_ConferenceTerminateResponse &() const
  5679. #else
  5680. GCC_ResponsePDU::operator GCC_ConferenceTerminateResponse &()
  5681. {
  5682. #ifndef PASN_LEANANDMEAN
  5683.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTerminateResponse::Class()), PInvalidCast);
  5684. #endif
  5685.   return *(GCC_ConferenceTerminateResponse *)choice;
  5686. }
  5687.  
  5688.  
  5689. GCC_ResponsePDU::operator const GCC_ConferenceTerminateResponse &() const
  5690. #endif
  5691. {
  5692. #ifndef PASN_LEANANDMEAN
  5693.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTerminateResponse::Class()), PInvalidCast);
  5694. #endif
  5695.   return *(GCC_ConferenceTerminateResponse *)choice;
  5696. }
  5697.  
  5698.  
  5699. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5700. GCC_ResponsePDU::operator GCC_ConferenceEjectUserResponse &() const
  5701. #else
  5702. GCC_ResponsePDU::operator GCC_ConferenceEjectUserResponse &()
  5703. {
  5704. #ifndef PASN_LEANANDMEAN
  5705.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceEjectUserResponse::Class()), PInvalidCast);
  5706. #endif
  5707.   return *(GCC_ConferenceEjectUserResponse *)choice;
  5708. }
  5709.  
  5710.  
  5711. GCC_ResponsePDU::operator const GCC_ConferenceEjectUserResponse &() const
  5712. #endif
  5713. {
  5714. #ifndef PASN_LEANANDMEAN
  5715.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceEjectUserResponse::Class()), PInvalidCast);
  5716. #endif
  5717.   return *(GCC_ConferenceEjectUserResponse *)choice;
  5718. }
  5719.  
  5720.  
  5721. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5722. GCC_ResponsePDU::operator GCC_ConferenceTransferResponse &() const
  5723. #else
  5724. GCC_ResponsePDU::operator GCC_ConferenceTransferResponse &()
  5725. {
  5726. #ifndef PASN_LEANANDMEAN
  5727.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTransferResponse::Class()), PInvalidCast);
  5728. #endif
  5729.   return *(GCC_ConferenceTransferResponse *)choice;
  5730. }
  5731.  
  5732.  
  5733. GCC_ResponsePDU::operator const GCC_ConferenceTransferResponse &() const
  5734. #endif
  5735. {
  5736. #ifndef PASN_LEANANDMEAN
  5737.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTransferResponse::Class()), PInvalidCast);
  5738. #endif
  5739.   return *(GCC_ConferenceTransferResponse *)choice;
  5740. }
  5741.  
  5742.  
  5743. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5744. GCC_ResponsePDU::operator GCC_RegistryResponse &() const
  5745. #else
  5746. GCC_ResponsePDU::operator GCC_RegistryResponse &()
  5747. {
  5748. #ifndef PASN_LEANANDMEAN
  5749.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryResponse::Class()), PInvalidCast);
  5750. #endif
  5751.   return *(GCC_RegistryResponse *)choice;
  5752. }
  5753.  
  5754.  
  5755. GCC_ResponsePDU::operator const GCC_RegistryResponse &() const
  5756. #endif
  5757. {
  5758. #ifndef PASN_LEANANDMEAN
  5759.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryResponse::Class()), PInvalidCast);
  5760. #endif
  5761.   return *(GCC_RegistryResponse *)choice;
  5762. }
  5763.  
  5764.  
  5765. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5766. GCC_ResponsePDU::operator GCC_RegistryAllocateHandleResponse &() const
  5767. #else
  5768. GCC_ResponsePDU::operator GCC_RegistryAllocateHandleResponse &()
  5769. {
  5770. #ifndef PASN_LEANANDMEAN
  5771.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryAllocateHandleResponse::Class()), PInvalidCast);
  5772. #endif
  5773.   return *(GCC_RegistryAllocateHandleResponse *)choice;
  5774. }
  5775.  
  5776.  
  5777. GCC_ResponsePDU::operator const GCC_RegistryAllocateHandleResponse &() const
  5778. #endif
  5779. {
  5780. #ifndef PASN_LEANANDMEAN
  5781.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryAllocateHandleResponse::Class()), PInvalidCast);
  5782. #endif
  5783.   return *(GCC_RegistryAllocateHandleResponse *)choice;
  5784. }
  5785.  
  5786.  
  5787. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5788. GCC_ResponsePDU::operator GCC_FunctionNotSupportedResponse &() const
  5789. #else
  5790. GCC_ResponsePDU::operator GCC_FunctionNotSupportedResponse &()
  5791. {
  5792. #ifndef PASN_LEANANDMEAN
  5793.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_FunctionNotSupportedResponse::Class()), PInvalidCast);
  5794. #endif
  5795.   return *(GCC_FunctionNotSupportedResponse *)choice;
  5796. }
  5797.  
  5798.  
  5799. GCC_ResponsePDU::operator const GCC_FunctionNotSupportedResponse &() const
  5800. #endif
  5801. {
  5802. #ifndef PASN_LEANANDMEAN
  5803.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_FunctionNotSupportedResponse::Class()), PInvalidCast);
  5804. #endif
  5805.   return *(GCC_FunctionNotSupportedResponse *)choice;
  5806. }
  5807.  
  5808.  
  5809. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5810. GCC_ResponsePDU::operator GCC_NonStandardPDU &() const
  5811. #else
  5812. GCC_ResponsePDU::operator GCC_NonStandardPDU &()
  5813. {
  5814. #ifndef PASN_LEANANDMEAN
  5815.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardPDU::Class()), PInvalidCast);
  5816. #endif
  5817.   return *(GCC_NonStandardPDU *)choice;
  5818. }
  5819.  
  5820.  
  5821. GCC_ResponsePDU::operator const GCC_NonStandardPDU &() const
  5822. #endif
  5823. {
  5824. #ifndef PASN_LEANANDMEAN
  5825.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardPDU::Class()), PInvalidCast);
  5826. #endif
  5827.   return *(GCC_NonStandardPDU *)choice;
  5828. }
  5829.  
  5830.  
  5831. BOOL GCC_ResponsePDU::CreateObject()
  5832. {
  5833.   switch (tag) {
  5834.     case e_conferenceJoinResponse :
  5835.       choice = new GCC_ConferenceJoinResponse();
  5836.       return TRUE;
  5837.     case e_conferenceAddResponse :
  5838.       choice = new GCC_ConferenceAddResponse();
  5839.       return TRUE;
  5840.     case e_conferenceLockResponse :
  5841.       choice = new GCC_ConferenceLockResponse();
  5842.       return TRUE;
  5843.     case e_conferenceUnlockResponse :
  5844.       choice = new GCC_ConferenceUnlockResponse();
  5845.       return TRUE;
  5846.     case e_conferenceTerminateResponse :
  5847.       choice = new GCC_ConferenceTerminateResponse();
  5848.       return TRUE;
  5849.     case e_conferenceEjectUserResponse :
  5850.       choice = new GCC_ConferenceEjectUserResponse();
  5851.       return TRUE;
  5852.     case e_conferenceTransferResponse :
  5853.       choice = new GCC_ConferenceTransferResponse();
  5854.       return TRUE;
  5855.     case e_registryResponse :
  5856.       choice = new GCC_RegistryResponse();
  5857.       return TRUE;
  5858.     case e_registryAllocateHandleResponse :
  5859.       choice = new GCC_RegistryAllocateHandleResponse();
  5860.       return TRUE;
  5861.     case e_functionNotSupportedResponse :
  5862.       choice = new GCC_FunctionNotSupportedResponse();
  5863.       return TRUE;
  5864.     case e_nonStandardResponse :
  5865.       choice = new GCC_NonStandardPDU();
  5866.       return TRUE;
  5867.   }
  5868.  
  5869.   choice = NULL;
  5870.   return FALSE;
  5871. }
  5872.  
  5873.  
  5874. PObject * GCC_ResponsePDU::Clone() const
  5875. {
  5876. #ifndef PASN_LEANANDMEAN
  5877.   PAssert(IsClass(GCC_ResponsePDU::Class()), PInvalidCast);
  5878. #endif
  5879.   return new GCC_ResponsePDU(*this);
  5880. }
  5881.  
  5882.  
  5883. //
  5884. // IndicationPDU
  5885. //
  5886.  
  5887. GCC_IndicationPDU::GCC_IndicationPDU(unsigned tag, PASN_Object::TagClass tagClass)
  5888.   : PASN_Choice(tag, tagClass, 19, TRUE
  5889. #ifndef PASN_NOPRINTON
  5890.       , "userIDIndication "
  5891.         "conferenceLockIndication "
  5892.         "conferenceUnlockIndication "
  5893.         "conferenceTerminateIndication "
  5894.         "conferenceEjectUserIndication "
  5895.         "conferenceTransferIndication "
  5896.         "rosterUpdateIndication "
  5897.         "applicationInvokeIndication "
  5898.         "registryMonitorEntryIndication "
  5899.         "conductorAssignIndication "
  5900.         "conductorReleaseIndication "
  5901.         "conductorPermissionAskIndication "
  5902.         "conductorPermissionGrantIndication "
  5903.         "conferenceTimeRemainingIndication "
  5904.         "conferenceTimeInquireIndication "
  5905.         "conferenceTimeExtendIndication "
  5906.         "conferenceAssistanceIndication "
  5907.         "textMessageIndication "
  5908.         "nonStandardIndication "
  5909. #endif
  5910.     )
  5911. {
  5912. }
  5913.  
  5914.  
  5915. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5916. GCC_IndicationPDU::operator GCC_UserIDIndication &() const
  5917. #else
  5918. GCC_IndicationPDU::operator GCC_UserIDIndication &()
  5919. {
  5920. #ifndef PASN_LEANANDMEAN
  5921.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_UserIDIndication::Class()), PInvalidCast);
  5922. #endif
  5923.   return *(GCC_UserIDIndication *)choice;
  5924. }
  5925.  
  5926.  
  5927. GCC_IndicationPDU::operator const GCC_UserIDIndication &() const
  5928. #endif
  5929. {
  5930. #ifndef PASN_LEANANDMEAN
  5931.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_UserIDIndication::Class()), PInvalidCast);
  5932. #endif
  5933.   return *(GCC_UserIDIndication *)choice;
  5934. }
  5935.  
  5936.  
  5937. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5938. GCC_IndicationPDU::operator GCC_ConferenceLockIndication &() const
  5939. #else
  5940. GCC_IndicationPDU::operator GCC_ConferenceLockIndication &()
  5941. {
  5942. #ifndef PASN_LEANANDMEAN
  5943.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceLockIndication::Class()), PInvalidCast);
  5944. #endif
  5945.   return *(GCC_ConferenceLockIndication *)choice;
  5946. }
  5947.  
  5948.  
  5949. GCC_IndicationPDU::operator const GCC_ConferenceLockIndication &() const
  5950. #endif
  5951. {
  5952. #ifndef PASN_LEANANDMEAN
  5953.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceLockIndication::Class()), PInvalidCast);
  5954. #endif
  5955.   return *(GCC_ConferenceLockIndication *)choice;
  5956. }
  5957.  
  5958.  
  5959. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5960. GCC_IndicationPDU::operator GCC_ConferenceUnlockIndication &() const
  5961. #else
  5962. GCC_IndicationPDU::operator GCC_ConferenceUnlockIndication &()
  5963. {
  5964. #ifndef PASN_LEANANDMEAN
  5965.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceUnlockIndication::Class()), PInvalidCast);
  5966. #endif
  5967.   return *(GCC_ConferenceUnlockIndication *)choice;
  5968. }
  5969.  
  5970.  
  5971. GCC_IndicationPDU::operator const GCC_ConferenceUnlockIndication &() const
  5972. #endif
  5973. {
  5974. #ifndef PASN_LEANANDMEAN
  5975.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceUnlockIndication::Class()), PInvalidCast);
  5976. #endif
  5977.   return *(GCC_ConferenceUnlockIndication *)choice;
  5978. }
  5979.  
  5980.  
  5981. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  5982. GCC_IndicationPDU::operator GCC_ConferenceTerminateIndication &() const
  5983. #else
  5984. GCC_IndicationPDU::operator GCC_ConferenceTerminateIndication &()
  5985. {
  5986. #ifndef PASN_LEANANDMEAN
  5987.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTerminateIndication::Class()), PInvalidCast);
  5988. #endif
  5989.   return *(GCC_ConferenceTerminateIndication *)choice;
  5990. }
  5991.  
  5992.  
  5993. GCC_IndicationPDU::operator const GCC_ConferenceTerminateIndication &() const
  5994. #endif
  5995. {
  5996. #ifndef PASN_LEANANDMEAN
  5997.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTerminateIndication::Class()), PInvalidCast);
  5998. #endif
  5999.   return *(GCC_ConferenceTerminateIndication *)choice;
  6000. }
  6001.  
  6002.  
  6003. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6004. GCC_IndicationPDU::operator GCC_ConferenceEjectUserIndication &() const
  6005. #else
  6006. GCC_IndicationPDU::operator GCC_ConferenceEjectUserIndication &()
  6007. {
  6008. #ifndef PASN_LEANANDMEAN
  6009.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceEjectUserIndication::Class()), PInvalidCast);
  6010. #endif
  6011.   return *(GCC_ConferenceEjectUserIndication *)choice;
  6012. }
  6013.  
  6014.  
  6015. GCC_IndicationPDU::operator const GCC_ConferenceEjectUserIndication &() const
  6016. #endif
  6017. {
  6018. #ifndef PASN_LEANANDMEAN
  6019.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceEjectUserIndication::Class()), PInvalidCast);
  6020. #endif
  6021.   return *(GCC_ConferenceEjectUserIndication *)choice;
  6022. }
  6023.  
  6024.  
  6025. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6026. GCC_IndicationPDU::operator GCC_ConferenceTransferIndication &() const
  6027. #else
  6028. GCC_IndicationPDU::operator GCC_ConferenceTransferIndication &()
  6029. {
  6030. #ifndef PASN_LEANANDMEAN
  6031.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTransferIndication::Class()), PInvalidCast);
  6032. #endif
  6033.   return *(GCC_ConferenceTransferIndication *)choice;
  6034. }
  6035.  
  6036.  
  6037. GCC_IndicationPDU::operator const GCC_ConferenceTransferIndication &() const
  6038. #endif
  6039. {
  6040. #ifndef PASN_LEANANDMEAN
  6041.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTransferIndication::Class()), PInvalidCast);
  6042. #endif
  6043.   return *(GCC_ConferenceTransferIndication *)choice;
  6044. }
  6045.  
  6046.  
  6047. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6048. GCC_IndicationPDU::operator GCC_RosterUpdateIndication &() const
  6049. #else
  6050. GCC_IndicationPDU::operator GCC_RosterUpdateIndication &()
  6051. {
  6052. #ifndef PASN_LEANANDMEAN
  6053.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication::Class()), PInvalidCast);
  6054. #endif
  6055.   return *(GCC_RosterUpdateIndication *)choice;
  6056. }
  6057.  
  6058.  
  6059. GCC_IndicationPDU::operator const GCC_RosterUpdateIndication &() const
  6060. #endif
  6061. {
  6062. #ifndef PASN_LEANANDMEAN
  6063.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication::Class()), PInvalidCast);
  6064. #endif
  6065.   return *(GCC_RosterUpdateIndication *)choice;
  6066. }
  6067.  
  6068.  
  6069. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6070. GCC_IndicationPDU::operator GCC_ApplicationInvokeIndication &() const
  6071. #else
  6072. GCC_IndicationPDU::operator GCC_ApplicationInvokeIndication &()
  6073. {
  6074. #ifndef PASN_LEANANDMEAN
  6075.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ApplicationInvokeIndication::Class()), PInvalidCast);
  6076. #endif
  6077.   return *(GCC_ApplicationInvokeIndication *)choice;
  6078. }
  6079.  
  6080.  
  6081. GCC_IndicationPDU::operator const GCC_ApplicationInvokeIndication &() const
  6082. #endif
  6083. {
  6084. #ifndef PASN_LEANANDMEAN
  6085.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ApplicationInvokeIndication::Class()), PInvalidCast);
  6086. #endif
  6087.   return *(GCC_ApplicationInvokeIndication *)choice;
  6088. }
  6089.  
  6090.  
  6091. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6092. GCC_IndicationPDU::operator GCC_RegistryMonitorEntryIndication &() const
  6093. #else
  6094. GCC_IndicationPDU::operator GCC_RegistryMonitorEntryIndication &()
  6095. {
  6096. #ifndef PASN_LEANANDMEAN
  6097.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryMonitorEntryIndication::Class()), PInvalidCast);
  6098. #endif
  6099.   return *(GCC_RegistryMonitorEntryIndication *)choice;
  6100. }
  6101.  
  6102.  
  6103. GCC_IndicationPDU::operator const GCC_RegistryMonitorEntryIndication &() const
  6104. #endif
  6105. {
  6106. #ifndef PASN_LEANANDMEAN
  6107.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RegistryMonitorEntryIndication::Class()), PInvalidCast);
  6108. #endif
  6109.   return *(GCC_RegistryMonitorEntryIndication *)choice;
  6110. }
  6111.  
  6112.  
  6113. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6114. GCC_IndicationPDU::operator GCC_ConductorAssignIndication &() const
  6115. #else
  6116. GCC_IndicationPDU::operator GCC_ConductorAssignIndication &()
  6117. {
  6118. #ifndef PASN_LEANANDMEAN
  6119.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConductorAssignIndication::Class()), PInvalidCast);
  6120. #endif
  6121.   return *(GCC_ConductorAssignIndication *)choice;
  6122. }
  6123.  
  6124.  
  6125. GCC_IndicationPDU::operator const GCC_ConductorAssignIndication &() const
  6126. #endif
  6127. {
  6128. #ifndef PASN_LEANANDMEAN
  6129.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConductorAssignIndication::Class()), PInvalidCast);
  6130. #endif
  6131.   return *(GCC_ConductorAssignIndication *)choice;
  6132. }
  6133.  
  6134.  
  6135. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6136. GCC_IndicationPDU::operator GCC_ConductorReleaseIndication &() const
  6137. #else
  6138. GCC_IndicationPDU::operator GCC_ConductorReleaseIndication &()
  6139. {
  6140. #ifndef PASN_LEANANDMEAN
  6141.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConductorReleaseIndication::Class()), PInvalidCast);
  6142. #endif
  6143.   return *(GCC_ConductorReleaseIndication *)choice;
  6144. }
  6145.  
  6146.  
  6147. GCC_IndicationPDU::operator const GCC_ConductorReleaseIndication &() const
  6148. #endif
  6149. {
  6150. #ifndef PASN_LEANANDMEAN
  6151.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConductorReleaseIndication::Class()), PInvalidCast);
  6152. #endif
  6153.   return *(GCC_ConductorReleaseIndication *)choice;
  6154. }
  6155.  
  6156.  
  6157. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6158. GCC_IndicationPDU::operator GCC_ConductorPermissionAskIndication &() const
  6159. #else
  6160. GCC_IndicationPDU::operator GCC_ConductorPermissionAskIndication &()
  6161. {
  6162. #ifndef PASN_LEANANDMEAN
  6163.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConductorPermissionAskIndication::Class()), PInvalidCast);
  6164. #endif
  6165.   return *(GCC_ConductorPermissionAskIndication *)choice;
  6166. }
  6167.  
  6168.  
  6169. GCC_IndicationPDU::operator const GCC_ConductorPermissionAskIndication &() const
  6170. #endif
  6171. {
  6172. #ifndef PASN_LEANANDMEAN
  6173.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConductorPermissionAskIndication::Class()), PInvalidCast);
  6174. #endif
  6175.   return *(GCC_ConductorPermissionAskIndication *)choice;
  6176. }
  6177.  
  6178.  
  6179. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6180. GCC_IndicationPDU::operator GCC_ConductorPermissionGrantIndication &() const
  6181. #else
  6182. GCC_IndicationPDU::operator GCC_ConductorPermissionGrantIndication &()
  6183. {
  6184. #ifndef PASN_LEANANDMEAN
  6185.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConductorPermissionGrantIndication::Class()), PInvalidCast);
  6186. #endif
  6187.   return *(GCC_ConductorPermissionGrantIndication *)choice;
  6188. }
  6189.  
  6190.  
  6191. GCC_IndicationPDU::operator const GCC_ConductorPermissionGrantIndication &() const
  6192. #endif
  6193. {
  6194. #ifndef PASN_LEANANDMEAN
  6195.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConductorPermissionGrantIndication::Class()), PInvalidCast);
  6196. #endif
  6197.   return *(GCC_ConductorPermissionGrantIndication *)choice;
  6198. }
  6199.  
  6200.  
  6201. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6202. GCC_IndicationPDU::operator GCC_ConferenceTimeRemainingIndication &() const
  6203. #else
  6204. GCC_IndicationPDU::operator GCC_ConferenceTimeRemainingIndication &()
  6205. {
  6206. #ifndef PASN_LEANANDMEAN
  6207.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTimeRemainingIndication::Class()), PInvalidCast);
  6208. #endif
  6209.   return *(GCC_ConferenceTimeRemainingIndication *)choice;
  6210. }
  6211.  
  6212.  
  6213. GCC_IndicationPDU::operator const GCC_ConferenceTimeRemainingIndication &() const
  6214. #endif
  6215. {
  6216. #ifndef PASN_LEANANDMEAN
  6217.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTimeRemainingIndication::Class()), PInvalidCast);
  6218. #endif
  6219.   return *(GCC_ConferenceTimeRemainingIndication *)choice;
  6220. }
  6221.  
  6222.  
  6223. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6224. GCC_IndicationPDU::operator GCC_ConferenceTimeInquireIndication &() const
  6225. #else
  6226. GCC_IndicationPDU::operator GCC_ConferenceTimeInquireIndication &()
  6227. {
  6228. #ifndef PASN_LEANANDMEAN
  6229.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTimeInquireIndication::Class()), PInvalidCast);
  6230. #endif
  6231.   return *(GCC_ConferenceTimeInquireIndication *)choice;
  6232. }
  6233.  
  6234.  
  6235. GCC_IndicationPDU::operator const GCC_ConferenceTimeInquireIndication &() const
  6236. #endif
  6237. {
  6238. #ifndef PASN_LEANANDMEAN
  6239.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTimeInquireIndication::Class()), PInvalidCast);
  6240. #endif
  6241.   return *(GCC_ConferenceTimeInquireIndication *)choice;
  6242. }
  6243.  
  6244.  
  6245. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6246. GCC_IndicationPDU::operator GCC_ConferenceTimeExtendIndication &() const
  6247. #else
  6248. GCC_IndicationPDU::operator GCC_ConferenceTimeExtendIndication &()
  6249. {
  6250. #ifndef PASN_LEANANDMEAN
  6251.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTimeExtendIndication::Class()), PInvalidCast);
  6252. #endif
  6253.   return *(GCC_ConferenceTimeExtendIndication *)choice;
  6254. }
  6255.  
  6256.  
  6257. GCC_IndicationPDU::operator const GCC_ConferenceTimeExtendIndication &() const
  6258. #endif
  6259. {
  6260. #ifndef PASN_LEANANDMEAN
  6261.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceTimeExtendIndication::Class()), PInvalidCast);
  6262. #endif
  6263.   return *(GCC_ConferenceTimeExtendIndication *)choice;
  6264. }
  6265.  
  6266.  
  6267. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6268. GCC_IndicationPDU::operator GCC_ConferenceAssistanceIndication &() const
  6269. #else
  6270. GCC_IndicationPDU::operator GCC_ConferenceAssistanceIndication &()
  6271. {
  6272. #ifndef PASN_LEANANDMEAN
  6273.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceAssistanceIndication::Class()), PInvalidCast);
  6274. #endif
  6275.   return *(GCC_ConferenceAssistanceIndication *)choice;
  6276. }
  6277.  
  6278.  
  6279. GCC_IndicationPDU::operator const GCC_ConferenceAssistanceIndication &() const
  6280. #endif
  6281. {
  6282. #ifndef PASN_LEANANDMEAN
  6283.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ConferenceAssistanceIndication::Class()), PInvalidCast);
  6284. #endif
  6285.   return *(GCC_ConferenceAssistanceIndication *)choice;
  6286. }
  6287.  
  6288.  
  6289. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6290. GCC_IndicationPDU::operator GCC_TextMessageIndication &() const
  6291. #else
  6292. GCC_IndicationPDU::operator GCC_TextMessageIndication &()
  6293. {
  6294. #ifndef PASN_LEANANDMEAN
  6295.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_TextMessageIndication::Class()), PInvalidCast);
  6296. #endif
  6297.   return *(GCC_TextMessageIndication *)choice;
  6298. }
  6299.  
  6300.  
  6301. GCC_IndicationPDU::operator const GCC_TextMessageIndication &() const
  6302. #endif
  6303. {
  6304. #ifndef PASN_LEANANDMEAN
  6305.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_TextMessageIndication::Class()), PInvalidCast);
  6306. #endif
  6307.   return *(GCC_TextMessageIndication *)choice;
  6308. }
  6309.  
  6310.  
  6311. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6312. GCC_IndicationPDU::operator GCC_NonStandardPDU &() const
  6313. #else
  6314. GCC_IndicationPDU::operator GCC_NonStandardPDU &()
  6315. {
  6316. #ifndef PASN_LEANANDMEAN
  6317.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardPDU::Class()), PInvalidCast);
  6318. #endif
  6319.   return *(GCC_NonStandardPDU *)choice;
  6320. }
  6321.  
  6322.  
  6323. GCC_IndicationPDU::operator const GCC_NonStandardPDU &() const
  6324. #endif
  6325. {
  6326. #ifndef PASN_LEANANDMEAN
  6327.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardPDU::Class()), PInvalidCast);
  6328. #endif
  6329.   return *(GCC_NonStandardPDU *)choice;
  6330. }
  6331.  
  6332.  
  6333. BOOL GCC_IndicationPDU::CreateObject()
  6334. {
  6335.   switch (tag) {
  6336.     case e_userIDIndication :
  6337.       choice = new GCC_UserIDIndication();
  6338.       return TRUE;
  6339.     case e_conferenceLockIndication :
  6340.       choice = new GCC_ConferenceLockIndication();
  6341.       return TRUE;
  6342.     case e_conferenceUnlockIndication :
  6343.       choice = new GCC_ConferenceUnlockIndication();
  6344.       return TRUE;
  6345.     case e_conferenceTerminateIndication :
  6346.       choice = new GCC_ConferenceTerminateIndication();
  6347.       return TRUE;
  6348.     case e_conferenceEjectUserIndication :
  6349.       choice = new GCC_ConferenceEjectUserIndication();
  6350.       return TRUE;
  6351.     case e_conferenceTransferIndication :
  6352.       choice = new GCC_ConferenceTransferIndication();
  6353.       return TRUE;
  6354.     case e_rosterUpdateIndication :
  6355.       choice = new GCC_RosterUpdateIndication();
  6356.       return TRUE;
  6357.     case e_applicationInvokeIndication :
  6358.       choice = new GCC_ApplicationInvokeIndication();
  6359.       return TRUE;
  6360.     case e_registryMonitorEntryIndication :
  6361.       choice = new GCC_RegistryMonitorEntryIndication();
  6362.       return TRUE;
  6363.     case e_conductorAssignIndication :
  6364.       choice = new GCC_ConductorAssignIndication();
  6365.       return TRUE;
  6366.     case e_conductorReleaseIndication :
  6367.       choice = new GCC_ConductorReleaseIndication();
  6368.       return TRUE;
  6369.     case e_conductorPermissionAskIndication :
  6370.       choice = new GCC_ConductorPermissionAskIndication();
  6371.       return TRUE;
  6372.     case e_conductorPermissionGrantIndication :
  6373.       choice = new GCC_ConductorPermissionGrantIndication();
  6374.       return TRUE;
  6375.     case e_conferenceTimeRemainingIndication :
  6376.       choice = new GCC_ConferenceTimeRemainingIndication();
  6377.       return TRUE;
  6378.     case e_conferenceTimeInquireIndication :
  6379.       choice = new GCC_ConferenceTimeInquireIndication();
  6380.       return TRUE;
  6381.     case e_conferenceTimeExtendIndication :
  6382.       choice = new GCC_ConferenceTimeExtendIndication();
  6383.       return TRUE;
  6384.     case e_conferenceAssistanceIndication :
  6385.       choice = new GCC_ConferenceAssistanceIndication();
  6386.       return TRUE;
  6387.     case e_textMessageIndication :
  6388.       choice = new GCC_TextMessageIndication();
  6389.       return TRUE;
  6390.     case e_nonStandardIndication :
  6391.       choice = new GCC_NonStandardPDU();
  6392.       return TRUE;
  6393.   }
  6394.  
  6395.   choice = NULL;
  6396.   return FALSE;
  6397. }
  6398.  
  6399.  
  6400. PObject * GCC_IndicationPDU::Clone() const
  6401. {
  6402. #ifndef PASN_LEANANDMEAN
  6403.   PAssert(IsClass(GCC_IndicationPDU::Class()), PInvalidCast);
  6404. #endif
  6405.   return new GCC_IndicationPDU(*this);
  6406. }
  6407.  
  6408.  
  6409. //
  6410. // UserData_subtype
  6411. //
  6412.  
  6413. GCC_UserData_subtype::GCC_UserData_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  6414.   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
  6415. {
  6416. }
  6417.  
  6418.  
  6419. #ifndef PASN_NOPRINTON
  6420. void GCC_UserData_subtype::PrintOn(ostream & strm) const
  6421. {
  6422.   int indent = strm.precision() + 2;
  6423.   strm << "{\n";
  6424.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  6425.   if (HasOptionalField(e_value))
  6426.     strm << setw(indent+8) << "value = " << setprecision(indent) << m_value << '\n';
  6427.   strm << setw(indent-1) << "}";
  6428. }
  6429. #endif
  6430.  
  6431.  
  6432. PObject::Comparison GCC_UserData_subtype::Compare(const PObject & obj) const
  6433. {
  6434. #ifndef PASN_LEANANDMEAN
  6435.   PAssert(IsDescendant(GCC_UserData_subtype::Class()), PInvalidCast);
  6436. #endif
  6437.   const GCC_UserData_subtype & other = (const GCC_UserData_subtype &)obj;
  6438.  
  6439.   Comparison result;
  6440.  
  6441.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  6442.     return result;
  6443.   if ((result = m_value.Compare(other.m_value)) != EqualTo)
  6444.     return result;
  6445.  
  6446.   return PASN_Sequence::Compare(other);
  6447. }
  6448.  
  6449.  
  6450. PINDEX GCC_UserData_subtype::GetDataLength() const
  6451. {
  6452.   PINDEX length = 0;
  6453.   length += m_key.GetObjectLength();
  6454.   if (HasOptionalField(e_value))
  6455.     length += m_value.GetObjectLength();
  6456.   return length;
  6457. }
  6458.  
  6459.  
  6460. BOOL GCC_UserData_subtype::Decode(PASN_Stream & strm)
  6461. {
  6462.   if (!PreambleDecode(strm))
  6463.     return FALSE;
  6464.  
  6465.   if (!m_key.Decode(strm))
  6466.     return FALSE;
  6467.   if (HasOptionalField(e_value) && !m_value.Decode(strm))
  6468.     return FALSE;
  6469.  
  6470.   return UnknownExtensionsDecode(strm);
  6471. }
  6472.  
  6473.  
  6474. void GCC_UserData_subtype::Encode(PASN_Stream & strm) const
  6475. {
  6476.   PreambleEncode(strm);
  6477.  
  6478.   m_key.Encode(strm);
  6479.   if (HasOptionalField(e_value))
  6480.     m_value.Encode(strm);
  6481.  
  6482.   UnknownExtensionsEncode(strm);
  6483. }
  6484.  
  6485.  
  6486. PObject * GCC_UserData_subtype::Clone() const
  6487. {
  6488. #ifndef PASN_LEANANDMEAN
  6489.   PAssert(IsClass(GCC_UserData_subtype::Class()), PInvalidCast);
  6490. #endif
  6491.   return new GCC_UserData_subtype(*this);
  6492. }
  6493.  
  6494.  
  6495. //
  6496. // ArrayOf_ChallengeItem
  6497. //
  6498.  
  6499. GCC_ArrayOf_ChallengeItem::GCC_ArrayOf_ChallengeItem(unsigned tag, PASN_Object::TagClass tagClass)
  6500.   : PASN_Array(tag, tagClass)
  6501. {
  6502. }
  6503.  
  6504.  
  6505. PASN_Object * GCC_ArrayOf_ChallengeItem::CreateObject() const
  6506. {
  6507.   return new GCC_ChallengeItem;
  6508. }
  6509.  
  6510.  
  6511. GCC_ChallengeItem & GCC_ArrayOf_ChallengeItem::operator[](PINDEX i) const
  6512. {
  6513.   return (GCC_ChallengeItem &)array[i];
  6514. }
  6515.  
  6516.  
  6517. PObject * GCC_ArrayOf_ChallengeItem::Clone() const
  6518. {
  6519. #ifndef PASN_LEANANDMEAN
  6520.   PAssert(IsClass(GCC_ArrayOf_ChallengeItem::Class()), PInvalidCast);
  6521. #endif
  6522.   return new GCC_ArrayOf_ChallengeItem(*this);
  6523. }
  6524.  
  6525.  
  6526. //
  6527. // NetworkAddress_subtype
  6528. //
  6529.  
  6530. GCC_NetworkAddress_subtype::GCC_NetworkAddress_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  6531.   : PASN_Choice(tag, tagClass, 3, TRUE
  6532. #ifndef PASN_NOPRINTON
  6533.       , "aggregatedChannel "
  6534.         "transportConnection "
  6535.         "nonStandard "
  6536. #endif
  6537.     )
  6538. {
  6539. }
  6540.  
  6541.  
  6542. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6543. GCC_NetworkAddress_subtype::operator GCC_NetworkAddress_subtype_aggregatedChannel &() const
  6544. #else
  6545. GCC_NetworkAddress_subtype::operator GCC_NetworkAddress_subtype_aggregatedChannel &()
  6546. {
  6547. #ifndef PASN_LEANANDMEAN
  6548.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NetworkAddress_subtype_aggregatedChannel::Class()), PInvalidCast);
  6549. #endif
  6550.   return *(GCC_NetworkAddress_subtype_aggregatedChannel *)choice;
  6551. }
  6552.  
  6553.  
  6554. GCC_NetworkAddress_subtype::operator const GCC_NetworkAddress_subtype_aggregatedChannel &() const
  6555. #endif
  6556. {
  6557. #ifndef PASN_LEANANDMEAN
  6558.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NetworkAddress_subtype_aggregatedChannel::Class()), PInvalidCast);
  6559. #endif
  6560.   return *(GCC_NetworkAddress_subtype_aggregatedChannel *)choice;
  6561. }
  6562.  
  6563.  
  6564. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6565. GCC_NetworkAddress_subtype::operator GCC_NetworkAddress_subtype_transportConnection &() const
  6566. #else
  6567. GCC_NetworkAddress_subtype::operator GCC_NetworkAddress_subtype_transportConnection &()
  6568. {
  6569. #ifndef PASN_LEANANDMEAN
  6570.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NetworkAddress_subtype_transportConnection::Class()), PInvalidCast);
  6571. #endif
  6572.   return *(GCC_NetworkAddress_subtype_transportConnection *)choice;
  6573. }
  6574.  
  6575.  
  6576. GCC_NetworkAddress_subtype::operator const GCC_NetworkAddress_subtype_transportConnection &() const
  6577. #endif
  6578. {
  6579. #ifndef PASN_LEANANDMEAN
  6580.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NetworkAddress_subtype_transportConnection::Class()), PInvalidCast);
  6581. #endif
  6582.   return *(GCC_NetworkAddress_subtype_transportConnection *)choice;
  6583. }
  6584.  
  6585.  
  6586. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  6587. GCC_NetworkAddress_subtype::operator GCC_NonStandardParameter &() const
  6588. #else
  6589. GCC_NetworkAddress_subtype::operator GCC_NonStandardParameter &()
  6590. {
  6591. #ifndef PASN_LEANANDMEAN
  6592.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardParameter::Class()), PInvalidCast);
  6593. #endif
  6594.   return *(GCC_NonStandardParameter *)choice;
  6595. }
  6596.  
  6597.  
  6598. GCC_NetworkAddress_subtype::operator const GCC_NonStandardParameter &() const
  6599. #endif
  6600. {
  6601. #ifndef PASN_LEANANDMEAN
  6602.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NonStandardParameter::Class()), PInvalidCast);
  6603. #endif
  6604.   return *(GCC_NonStandardParameter *)choice;
  6605. }
  6606.  
  6607.  
  6608. BOOL GCC_NetworkAddress_subtype::CreateObject()
  6609. {
  6610.   switch (tag) {
  6611.     case e_aggregatedChannel :
  6612.       choice = new GCC_NetworkAddress_subtype_aggregatedChannel();
  6613.       return TRUE;
  6614.     case e_transportConnection :
  6615.       choice = new GCC_NetworkAddress_subtype_transportConnection();
  6616.       return TRUE;
  6617.     case e_nonStandard :
  6618.       choice = new GCC_NonStandardParameter();
  6619.       return TRUE;
  6620.   }
  6621.  
  6622.   choice = NULL;
  6623.   return FALSE;
  6624. }
  6625.  
  6626.  
  6627. PObject * GCC_NetworkAddress_subtype::Clone() const
  6628. {
  6629. #ifndef PASN_LEANANDMEAN
  6630.   PAssert(IsClass(GCC_NetworkAddress_subtype::Class()), PInvalidCast);
  6631. #endif
  6632.   return new GCC_NetworkAddress_subtype(*this);
  6633. }
  6634.  
  6635.  
  6636. //
  6637. // ArrayOf_TextString
  6638. //
  6639.  
  6640. GCC_ArrayOf_TextString::GCC_ArrayOf_TextString(unsigned tag, PASN_Object::TagClass tagClass)
  6641.   : PASN_Array(tag, tagClass)
  6642. {
  6643. }
  6644.  
  6645.  
  6646. PASN_Object * GCC_ArrayOf_TextString::CreateObject() const
  6647. {
  6648.   return new GCC_TextString;
  6649. }
  6650.  
  6651.  
  6652. GCC_TextString & GCC_ArrayOf_TextString::operator[](PINDEX i) const
  6653. {
  6654.   return (GCC_TextString &)array[i];
  6655. }
  6656.  
  6657.  
  6658. PObject * GCC_ArrayOf_TextString::Clone() const
  6659. {
  6660. #ifndef PASN_LEANANDMEAN
  6661.   PAssert(IsClass(GCC_ArrayOf_TextString::Class()), PInvalidCast);
  6662. #endif
  6663.   return new GCC_ArrayOf_TextString(*this);
  6664. }
  6665.  
  6666.  
  6667. //
  6668. // ApplicationRecord_nonCollapsingCapabilities
  6669. //
  6670.  
  6671. GCC_ApplicationRecord_nonCollapsingCapabilities::GCC_ApplicationRecord_nonCollapsingCapabilities(unsigned tag, PASN_Object::TagClass tagClass)
  6672.   : PASN_Array(tag, tagClass)
  6673. {
  6674. }
  6675.  
  6676.  
  6677. PASN_Object * GCC_ApplicationRecord_nonCollapsingCapabilities::CreateObject() const
  6678. {
  6679.   return new GCC_ApplicationRecord_nonCollapsingCapabilities_subtype;
  6680. }
  6681.  
  6682.  
  6683. GCC_ApplicationRecord_nonCollapsingCapabilities_subtype & GCC_ApplicationRecord_nonCollapsingCapabilities::operator[](PINDEX i) const
  6684. {
  6685.   return (GCC_ApplicationRecord_nonCollapsingCapabilities_subtype &)array[i];
  6686. }
  6687.  
  6688.  
  6689. PObject * GCC_ApplicationRecord_nonCollapsingCapabilities::Clone() const
  6690. {
  6691. #ifndef PASN_LEANANDMEAN
  6692.   PAssert(IsClass(GCC_ApplicationRecord_nonCollapsingCapabilities::Class()), PInvalidCast);
  6693. #endif
  6694.   return new GCC_ApplicationRecord_nonCollapsingCapabilities(*this);
  6695. }
  6696.  
  6697.  
  6698. //
  6699. // ApplicationInvokeSpecifier_expectedCapabilitySet
  6700. //
  6701.  
  6702. GCC_ApplicationInvokeSpecifier_expectedCapabilitySet::GCC_ApplicationInvokeSpecifier_expectedCapabilitySet(unsigned tag, PASN_Object::TagClass tagClass)
  6703.   : PASN_Array(tag, tagClass)
  6704. {
  6705. }
  6706.  
  6707.  
  6708. PASN_Object * GCC_ApplicationInvokeSpecifier_expectedCapabilitySet::CreateObject() const
  6709. {
  6710.   return new GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype;
  6711. }
  6712.  
  6713.  
  6714. GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype & GCC_ApplicationInvokeSpecifier_expectedCapabilitySet::operator[](PINDEX i) const
  6715. {
  6716.   return (GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype &)array[i];
  6717. }
  6718.  
  6719.  
  6720. PObject * GCC_ApplicationInvokeSpecifier_expectedCapabilitySet::Clone() const
  6721. {
  6722. #ifndef PASN_LEANANDMEAN
  6723.   PAssert(IsClass(GCC_ApplicationInvokeSpecifier_expectedCapabilitySet::Class()), PInvalidCast);
  6724. #endif
  6725.   return new GCC_ApplicationInvokeSpecifier_expectedCapabilitySet(*this);
  6726. }
  6727.  
  6728.  
  6729. //
  6730. // RegistryEntryOwner_owned
  6731. //
  6732.  
  6733. GCC_RegistryEntryOwner_owned::GCC_RegistryEntryOwner_owned(unsigned tag, PASN_Object::TagClass tagClass)
  6734.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  6735. {
  6736. }
  6737.  
  6738.  
  6739. #ifndef PASN_NOPRINTON
  6740. void GCC_RegistryEntryOwner_owned::PrintOn(ostream & strm) const
  6741. {
  6742.   int indent = strm.precision() + 2;
  6743.   strm << "{\n";
  6744.   strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  6745.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  6746.   strm << setw(indent-1) << "}";
  6747. }
  6748. #endif
  6749.  
  6750.  
  6751. PObject::Comparison GCC_RegistryEntryOwner_owned::Compare(const PObject & obj) const
  6752. {
  6753. #ifndef PASN_LEANANDMEAN
  6754.   PAssert(IsDescendant(GCC_RegistryEntryOwner_owned::Class()), PInvalidCast);
  6755. #endif
  6756.   const GCC_RegistryEntryOwner_owned & other = (const GCC_RegistryEntryOwner_owned &)obj;
  6757.  
  6758.   Comparison result;
  6759.  
  6760.   if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
  6761.     return result;
  6762.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  6763.     return result;
  6764.  
  6765.   return PASN_Sequence::Compare(other);
  6766. }
  6767.  
  6768.  
  6769. PINDEX GCC_RegistryEntryOwner_owned::GetDataLength() const
  6770. {
  6771.   PINDEX length = 0;
  6772.   length += m_nodeID.GetObjectLength();
  6773.   length += m_entityID.GetObjectLength();
  6774.   return length;
  6775. }
  6776.  
  6777.  
  6778. BOOL GCC_RegistryEntryOwner_owned::Decode(PASN_Stream & strm)
  6779. {
  6780.   if (!PreambleDecode(strm))
  6781.     return FALSE;
  6782.  
  6783.   if (!m_nodeID.Decode(strm))
  6784.     return FALSE;
  6785.   if (!m_entityID.Decode(strm))
  6786.     return FALSE;
  6787.  
  6788.   return UnknownExtensionsDecode(strm);
  6789. }
  6790.  
  6791.  
  6792. void GCC_RegistryEntryOwner_owned::Encode(PASN_Stream & strm) const
  6793. {
  6794.   PreambleEncode(strm);
  6795.  
  6796.   m_nodeID.Encode(strm);
  6797.   m_entityID.Encode(strm);
  6798.  
  6799.   UnknownExtensionsEncode(strm);
  6800. }
  6801.  
  6802.  
  6803. PObject * GCC_RegistryEntryOwner_owned::Clone() const
  6804. {
  6805. #ifndef PASN_LEANANDMEAN
  6806.   PAssert(IsClass(GCC_RegistryEntryOwner_owned::Class()), PInvalidCast);
  6807. #endif
  6808.   return new GCC_RegistryEntryOwner_owned(*this);
  6809. }
  6810.  
  6811.  
  6812. //
  6813. // ArrayOf_Privilege
  6814. //
  6815.  
  6816. GCC_ArrayOf_Privilege::GCC_ArrayOf_Privilege(unsigned tag, PASN_Object::TagClass tagClass)
  6817.   : PASN_Array(tag, tagClass)
  6818. {
  6819. }
  6820.  
  6821.  
  6822. PASN_Object * GCC_ArrayOf_Privilege::CreateObject() const
  6823. {
  6824.   return new GCC_Privilege;
  6825. }
  6826.  
  6827.  
  6828. GCC_Privilege & GCC_ArrayOf_Privilege::operator[](PINDEX i) const
  6829. {
  6830.   return (GCC_Privilege &)array[i];
  6831. }
  6832.  
  6833.  
  6834. PObject * GCC_ArrayOf_Privilege::Clone() const
  6835. {
  6836. #ifndef PASN_LEANANDMEAN
  6837.   PAssert(IsClass(GCC_ArrayOf_Privilege::Class()), PInvalidCast);
  6838. #endif
  6839.   return new GCC_ArrayOf_Privilege(*this);
  6840. }
  6841.  
  6842.  
  6843. //
  6844. // ConferenceCreateResponse_result
  6845. //
  6846.  
  6847. GCC_ConferenceCreateResponse_result::GCC_ConferenceCreateResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  6848.   : PASN_Enumeration(tag, tagClass, 4, TRUE
  6849. #ifndef PASN_NOPRINTON
  6850.       , "success "
  6851.         "userRejected "
  6852.         "resourcesNotAvailable "
  6853.         "rejectedForSymmetryBreaking "
  6854.         "lockedConferenceNotSupported "
  6855. #endif
  6856.     )
  6857. {
  6858. }
  6859.  
  6860.  
  6861. GCC_ConferenceCreateResponse_result & GCC_ConferenceCreateResponse_result::operator=(unsigned v)
  6862. {
  6863.   SetValue(v);
  6864.   return *this;
  6865. }
  6866.  
  6867.  
  6868. PObject * GCC_ConferenceCreateResponse_result::Clone() const
  6869. {
  6870. #ifndef PASN_LEANANDMEAN
  6871.   PAssert(IsClass(GCC_ConferenceCreateResponse_result::Class()), PInvalidCast);
  6872. #endif
  6873.   return new GCC_ConferenceCreateResponse_result(*this);
  6874. }
  6875.  
  6876.  
  6877. //
  6878. // ArrayOf_ConferenceDescriptor
  6879. //
  6880.  
  6881. GCC_ArrayOf_ConferenceDescriptor::GCC_ArrayOf_ConferenceDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
  6882.   : PASN_Array(tag, tagClass)
  6883. {
  6884. }
  6885.  
  6886.  
  6887. PASN_Object * GCC_ArrayOf_ConferenceDescriptor::CreateObject() const
  6888. {
  6889.   return new GCC_ConferenceDescriptor;
  6890. }
  6891.  
  6892.  
  6893. GCC_ConferenceDescriptor & GCC_ArrayOf_ConferenceDescriptor::operator[](PINDEX i) const
  6894. {
  6895.   return (GCC_ConferenceDescriptor &)array[i];
  6896. }
  6897.  
  6898.  
  6899. PObject * GCC_ArrayOf_ConferenceDescriptor::Clone() const
  6900. {
  6901. #ifndef PASN_LEANANDMEAN
  6902.   PAssert(IsClass(GCC_ArrayOf_ConferenceDescriptor::Class()), PInvalidCast);
  6903. #endif
  6904.   return new GCC_ArrayOf_ConferenceDescriptor(*this);
  6905. }
  6906.  
  6907.  
  6908. //
  6909. // ConferenceQueryResponse_result
  6910. //
  6911.  
  6912. GCC_ConferenceQueryResponse_result::GCC_ConferenceQueryResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  6913.   : PASN_Enumeration(tag, tagClass, 1, TRUE
  6914. #ifndef PASN_NOPRINTON
  6915.       , "success "
  6916.         "userRejected "
  6917. #endif
  6918.     )
  6919. {
  6920. }
  6921.  
  6922.  
  6923. GCC_ConferenceQueryResponse_result & GCC_ConferenceQueryResponse_result::operator=(unsigned v)
  6924. {
  6925.   SetValue(v);
  6926.   return *this;
  6927. }
  6928.  
  6929.  
  6930. PObject * GCC_ConferenceQueryResponse_result::Clone() const
  6931. {
  6932. #ifndef PASN_LEANANDMEAN
  6933.   PAssert(IsClass(GCC_ConferenceQueryResponse_result::Class()), PInvalidCast);
  6934. #endif
  6935.   return new GCC_ConferenceQueryResponse_result(*this);
  6936. }
  6937.  
  6938.  
  6939. //
  6940. // ConferenceJoinResponse_result
  6941. //
  6942.  
  6943. GCC_ConferenceJoinResponse_result::GCC_ConferenceJoinResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  6944.   : PASN_Enumeration(tag, tagClass, 6, TRUE
  6945. #ifndef PASN_NOPRINTON
  6946.       , "success "
  6947.         "userRejected "
  6948.         "invalidConference "
  6949.         "invalidPassword "
  6950.         "invalidConvenerPassword "
  6951.         "challengeResponseRequired "
  6952.         "invalidChallengeResponse "
  6953. #endif
  6954.     )
  6955. {
  6956. }
  6957.  
  6958.  
  6959. GCC_ConferenceJoinResponse_result & GCC_ConferenceJoinResponse_result::operator=(unsigned v)
  6960. {
  6961.   SetValue(v);
  6962.   return *this;
  6963. }
  6964.  
  6965.  
  6966. PObject * GCC_ConferenceJoinResponse_result::Clone() const
  6967. {
  6968. #ifndef PASN_LEANANDMEAN
  6969.   PAssert(IsClass(GCC_ConferenceJoinResponse_result::Class()), PInvalidCast);
  6970. #endif
  6971.   return new GCC_ConferenceJoinResponse_result(*this);
  6972. }
  6973.  
  6974.  
  6975. //
  6976. // ConferenceInviteResponse_result
  6977. //
  6978.  
  6979. GCC_ConferenceInviteResponse_result::GCC_ConferenceInviteResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  6980.   : PASN_Enumeration(tag, tagClass, 1, TRUE
  6981. #ifndef PASN_NOPRINTON
  6982.       , "success "
  6983.         "userRejected "
  6984. #endif
  6985.     )
  6986. {
  6987. }
  6988.  
  6989.  
  6990. GCC_ConferenceInviteResponse_result & GCC_ConferenceInviteResponse_result::operator=(unsigned v)
  6991. {
  6992.   SetValue(v);
  6993.   return *this;
  6994. }
  6995.  
  6996.  
  6997. PObject * GCC_ConferenceInviteResponse_result::Clone() const
  6998. {
  6999. #ifndef PASN_LEANANDMEAN
  7000.   PAssert(IsClass(GCC_ConferenceInviteResponse_result::Class()), PInvalidCast);
  7001. #endif
  7002.   return new GCC_ConferenceInviteResponse_result(*this);
  7003. }
  7004.  
  7005.  
  7006. //
  7007. // ConferenceAddResponse_result
  7008. //
  7009.  
  7010. GCC_ConferenceAddResponse_result::GCC_ConferenceAddResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  7011.   : PASN_Enumeration(tag, tagClass, 7, TRUE
  7012. #ifndef PASN_NOPRINTON
  7013.       , "success "
  7014.         "invalidRequester "
  7015.         "invalidNetworkType "
  7016.         "invalidNetworkAddress "
  7017.         "addedNodeBusy "
  7018.         "networkBusy "
  7019.         "noPortsAvailable "
  7020.         "connectionUnsuccessful "
  7021. #endif
  7022.     )
  7023. {
  7024. }
  7025.  
  7026.  
  7027. GCC_ConferenceAddResponse_result & GCC_ConferenceAddResponse_result::operator=(unsigned v)
  7028. {
  7029.   SetValue(v);
  7030.   return *this;
  7031. }
  7032.  
  7033.  
  7034. PObject * GCC_ConferenceAddResponse_result::Clone() const
  7035. {
  7036. #ifndef PASN_LEANANDMEAN
  7037.   PAssert(IsClass(GCC_ConferenceAddResponse_result::Class()), PInvalidCast);
  7038. #endif
  7039.   return new GCC_ConferenceAddResponse_result(*this);
  7040. }
  7041.  
  7042.  
  7043. //
  7044. // ConferenceLockResponse_result
  7045. //
  7046.  
  7047. GCC_ConferenceLockResponse_result::GCC_ConferenceLockResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  7048.   : PASN_Enumeration(tag, tagClass, 2, TRUE
  7049. #ifndef PASN_NOPRINTON
  7050.       , "success "
  7051.         "invalidRequester "
  7052.         "alreadyLocked "
  7053. #endif
  7054.     )
  7055. {
  7056. }
  7057.  
  7058.  
  7059. GCC_ConferenceLockResponse_result & GCC_ConferenceLockResponse_result::operator=(unsigned v)
  7060. {
  7061.   SetValue(v);
  7062.   return *this;
  7063. }
  7064.  
  7065.  
  7066. PObject * GCC_ConferenceLockResponse_result::Clone() const
  7067. {
  7068. #ifndef PASN_LEANANDMEAN
  7069.   PAssert(IsClass(GCC_ConferenceLockResponse_result::Class()), PInvalidCast);
  7070. #endif
  7071.   return new GCC_ConferenceLockResponse_result(*this);
  7072. }
  7073.  
  7074.  
  7075. //
  7076. // ConferenceUnlockResponse_result
  7077. //
  7078.  
  7079. GCC_ConferenceUnlockResponse_result::GCC_ConferenceUnlockResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  7080.   : PASN_Enumeration(tag, tagClass, 2, TRUE
  7081. #ifndef PASN_NOPRINTON
  7082.       , "success "
  7083.         "invalidRequester "
  7084.         "alreadyUnlocked "
  7085. #endif
  7086.     )
  7087. {
  7088. }
  7089.  
  7090.  
  7091. GCC_ConferenceUnlockResponse_result & GCC_ConferenceUnlockResponse_result::operator=(unsigned v)
  7092. {
  7093.   SetValue(v);
  7094.   return *this;
  7095. }
  7096.  
  7097.  
  7098. PObject * GCC_ConferenceUnlockResponse_result::Clone() const
  7099. {
  7100. #ifndef PASN_LEANANDMEAN
  7101.   PAssert(IsClass(GCC_ConferenceUnlockResponse_result::Class()), PInvalidCast);
  7102. #endif
  7103.   return new GCC_ConferenceUnlockResponse_result(*this);
  7104. }
  7105.  
  7106.  
  7107. //
  7108. // ConferenceTerminateRequest_reason
  7109. //
  7110.  
  7111. GCC_ConferenceTerminateRequest_reason::GCC_ConferenceTerminateRequest_reason(unsigned tag, PASN_Object::TagClass tagClass)
  7112.   : PASN_Enumeration(tag, tagClass, 1, TRUE
  7113. #ifndef PASN_NOPRINTON
  7114.       , "userInitiated "
  7115.         "timedConferenceTermination "
  7116. #endif
  7117.     )
  7118. {
  7119. }
  7120.  
  7121.  
  7122. GCC_ConferenceTerminateRequest_reason & GCC_ConferenceTerminateRequest_reason::operator=(unsigned v)
  7123. {
  7124.   SetValue(v);
  7125.   return *this;
  7126. }
  7127.  
  7128.  
  7129. PObject * GCC_ConferenceTerminateRequest_reason::Clone() const
  7130. {
  7131. #ifndef PASN_LEANANDMEAN
  7132.   PAssert(IsClass(GCC_ConferenceTerminateRequest_reason::Class()), PInvalidCast);
  7133. #endif
  7134.   return new GCC_ConferenceTerminateRequest_reason(*this);
  7135. }
  7136.  
  7137.  
  7138. //
  7139. // ConferenceTerminateResponse_result
  7140. //
  7141.  
  7142. GCC_ConferenceTerminateResponse_result::GCC_ConferenceTerminateResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  7143.   : PASN_Enumeration(tag, tagClass, 1, TRUE
  7144. #ifndef PASN_NOPRINTON
  7145.       , "success "
  7146.         "invalidRequester "
  7147. #endif
  7148.     )
  7149. {
  7150. }
  7151.  
  7152.  
  7153. GCC_ConferenceTerminateResponse_result & GCC_ConferenceTerminateResponse_result::operator=(unsigned v)
  7154. {
  7155.   SetValue(v);
  7156.   return *this;
  7157. }
  7158.  
  7159.  
  7160. PObject * GCC_ConferenceTerminateResponse_result::Clone() const
  7161. {
  7162. #ifndef PASN_LEANANDMEAN
  7163.   PAssert(IsClass(GCC_ConferenceTerminateResponse_result::Class()), PInvalidCast);
  7164. #endif
  7165.   return new GCC_ConferenceTerminateResponse_result(*this);
  7166. }
  7167.  
  7168.  
  7169. //
  7170. // ConferenceTerminateIndication_reason
  7171. //
  7172.  
  7173. GCC_ConferenceTerminateIndication_reason::GCC_ConferenceTerminateIndication_reason(unsigned tag, PASN_Object::TagClass tagClass)
  7174.   : PASN_Enumeration(tag, tagClass, 1, TRUE
  7175. #ifndef PASN_NOPRINTON
  7176.       , "userInitiated "
  7177.         "timedConferenceTermination "
  7178. #endif
  7179.     )
  7180. {
  7181. }
  7182.  
  7183.  
  7184. GCC_ConferenceTerminateIndication_reason & GCC_ConferenceTerminateIndication_reason::operator=(unsigned v)
  7185. {
  7186.   SetValue(v);
  7187.   return *this;
  7188. }
  7189.  
  7190.  
  7191. PObject * GCC_ConferenceTerminateIndication_reason::Clone() const
  7192. {
  7193. #ifndef PASN_LEANANDMEAN
  7194.   PAssert(IsClass(GCC_ConferenceTerminateIndication_reason::Class()), PInvalidCast);
  7195. #endif
  7196.   return new GCC_ConferenceTerminateIndication_reason(*this);
  7197. }
  7198.  
  7199.  
  7200. //
  7201. // ConferenceEjectUserRequest_reason
  7202. //
  7203.  
  7204. GCC_ConferenceEjectUserRequest_reason::GCC_ConferenceEjectUserRequest_reason(unsigned tag, PASN_Object::TagClass tagClass)
  7205.   : PASN_Enumeration(tag, tagClass, 0, TRUE
  7206. #ifndef PASN_NOPRINTON
  7207.       , "userInitiated "
  7208. #endif
  7209.     )
  7210. {
  7211. }
  7212.  
  7213.  
  7214. GCC_ConferenceEjectUserRequest_reason & GCC_ConferenceEjectUserRequest_reason::operator=(unsigned v)
  7215. {
  7216.   SetValue(v);
  7217.   return *this;
  7218. }
  7219.  
  7220.  
  7221. PObject * GCC_ConferenceEjectUserRequest_reason::Clone() const
  7222. {
  7223. #ifndef PASN_LEANANDMEAN
  7224.   PAssert(IsClass(GCC_ConferenceEjectUserRequest_reason::Class()), PInvalidCast);
  7225. #endif
  7226.   return new GCC_ConferenceEjectUserRequest_reason(*this);
  7227. }
  7228.  
  7229.  
  7230. //
  7231. // ConferenceEjectUserResponse_result
  7232. //
  7233.  
  7234. GCC_ConferenceEjectUserResponse_result::GCC_ConferenceEjectUserResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  7235.   : PASN_Enumeration(tag, tagClass, 2, TRUE
  7236. #ifndef PASN_NOPRINTON
  7237.       , "success "
  7238.         "invalidRequester "
  7239.         "invalidNode "
  7240. #endif
  7241.     )
  7242. {
  7243. }
  7244.  
  7245.  
  7246. GCC_ConferenceEjectUserResponse_result & GCC_ConferenceEjectUserResponse_result::operator=(unsigned v)
  7247. {
  7248.   SetValue(v);
  7249.   return *this;
  7250. }
  7251.  
  7252.  
  7253. PObject * GCC_ConferenceEjectUserResponse_result::Clone() const
  7254. {
  7255. #ifndef PASN_LEANANDMEAN
  7256.   PAssert(IsClass(GCC_ConferenceEjectUserResponse_result::Class()), PInvalidCast);
  7257. #endif
  7258.   return new GCC_ConferenceEjectUserResponse_result(*this);
  7259. }
  7260.  
  7261.  
  7262. //
  7263. // ConferenceEjectUserIndication_reason
  7264. //
  7265.  
  7266. GCC_ConferenceEjectUserIndication_reason::GCC_ConferenceEjectUserIndication_reason(unsigned tag, PASN_Object::TagClass tagClass)
  7267.   : PASN_Enumeration(tag, tagClass, 2, TRUE
  7268. #ifndef PASN_NOPRINTON
  7269.       , "userInitiated "
  7270.         "higherNodeDisconnected "
  7271.         "higherNodeEjected "
  7272. #endif
  7273.     )
  7274. {
  7275. }
  7276.  
  7277.  
  7278. GCC_ConferenceEjectUserIndication_reason & GCC_ConferenceEjectUserIndication_reason::operator=(unsigned v)
  7279. {
  7280.   SetValue(v);
  7281.   return *this;
  7282. }
  7283.  
  7284.  
  7285. PObject * GCC_ConferenceEjectUserIndication_reason::Clone() const
  7286. {
  7287. #ifndef PASN_LEANANDMEAN
  7288.   PAssert(IsClass(GCC_ConferenceEjectUserIndication_reason::Class()), PInvalidCast);
  7289. #endif
  7290.   return new GCC_ConferenceEjectUserIndication_reason(*this);
  7291. }
  7292.  
  7293.  
  7294. //
  7295. // ArrayOf_UserID
  7296. //
  7297.  
  7298. GCC_ArrayOf_UserID::GCC_ArrayOf_UserID(unsigned tag, PASN_Object::TagClass tagClass)
  7299.   : PASN_Array(tag, tagClass)
  7300. {
  7301. }
  7302.  
  7303.  
  7304. PASN_Object * GCC_ArrayOf_UserID::CreateObject() const
  7305. {
  7306.   return new GCC_UserID;
  7307. }
  7308.  
  7309.  
  7310. GCC_UserID & GCC_ArrayOf_UserID::operator[](PINDEX i) const
  7311. {
  7312.   return (GCC_UserID &)array[i];
  7313. }
  7314.  
  7315.  
  7316. PObject * GCC_ArrayOf_UserID::Clone() const
  7317. {
  7318. #ifndef PASN_LEANANDMEAN
  7319.   PAssert(IsClass(GCC_ArrayOf_UserID::Class()), PInvalidCast);
  7320. #endif
  7321.   return new GCC_ArrayOf_UserID(*this);
  7322. }
  7323.  
  7324.  
  7325. //
  7326. // ConferenceTransferResponse_result
  7327. //
  7328.  
  7329. GCC_ConferenceTransferResponse_result::GCC_ConferenceTransferResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  7330.   : PASN_Enumeration(tag, tagClass, 1, TRUE
  7331. #ifndef PASN_NOPRINTON
  7332.       , "success "
  7333.         "invalidRequester "
  7334. #endif
  7335.     )
  7336. {
  7337. }
  7338.  
  7339.  
  7340. GCC_ConferenceTransferResponse_result & GCC_ConferenceTransferResponse_result::operator=(unsigned v)
  7341. {
  7342.   SetValue(v);
  7343.   return *this;
  7344. }
  7345.  
  7346.  
  7347. PObject * GCC_ConferenceTransferResponse_result::Clone() const
  7348. {
  7349. #ifndef PASN_LEANANDMEAN
  7350.   PAssert(IsClass(GCC_ConferenceTransferResponse_result::Class()), PInvalidCast);
  7351. #endif
  7352.   return new GCC_ConferenceTransferResponse_result(*this);
  7353. }
  7354.  
  7355.  
  7356. //
  7357. // RosterUpdateIndication_applicationInformation
  7358. //
  7359.  
  7360. GCC_RosterUpdateIndication_applicationInformation::GCC_RosterUpdateIndication_applicationInformation(unsigned tag, PASN_Object::TagClass tagClass)
  7361.   : PASN_Array(tag, tagClass)
  7362. {
  7363.   SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  7364. }
  7365.  
  7366.  
  7367. PASN_Object * GCC_RosterUpdateIndication_applicationInformation::CreateObject() const
  7368. {
  7369.   return new GCC_RosterUpdateIndication_applicationInformation_subtype;
  7370. }
  7371.  
  7372.  
  7373. GCC_RosterUpdateIndication_applicationInformation_subtype & GCC_RosterUpdateIndication_applicationInformation::operator[](PINDEX i) const
  7374. {
  7375.   return (GCC_RosterUpdateIndication_applicationInformation_subtype &)array[i];
  7376. }
  7377.  
  7378.  
  7379. PObject * GCC_RosterUpdateIndication_applicationInformation::Clone() const
  7380. {
  7381. #ifndef PASN_LEANANDMEAN
  7382.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation::Class()), PInvalidCast);
  7383. #endif
  7384.   return new GCC_RosterUpdateIndication_applicationInformation(*this);
  7385. }
  7386.  
  7387.  
  7388. //
  7389. // ArrayOf_ApplicationInvokeSpecifier
  7390. //
  7391.  
  7392. GCC_ArrayOf_ApplicationInvokeSpecifier::GCC_ArrayOf_ApplicationInvokeSpecifier(unsigned tag, PASN_Object::TagClass tagClass)
  7393.   : PASN_Array(tag, tagClass)
  7394. {
  7395. }
  7396.  
  7397.  
  7398. PASN_Object * GCC_ArrayOf_ApplicationInvokeSpecifier::CreateObject() const
  7399. {
  7400.   return new GCC_ApplicationInvokeSpecifier;
  7401. }
  7402.  
  7403.  
  7404. GCC_ApplicationInvokeSpecifier & GCC_ArrayOf_ApplicationInvokeSpecifier::operator[](PINDEX i) const
  7405. {
  7406.   return (GCC_ApplicationInvokeSpecifier &)array[i];
  7407. }
  7408.  
  7409.  
  7410. PObject * GCC_ArrayOf_ApplicationInvokeSpecifier::Clone() const
  7411. {
  7412. #ifndef PASN_LEANANDMEAN
  7413.   PAssert(IsClass(GCC_ArrayOf_ApplicationInvokeSpecifier::Class()), PInvalidCast);
  7414. #endif
  7415.   return new GCC_ArrayOf_ApplicationInvokeSpecifier(*this);
  7416. }
  7417.  
  7418.  
  7419. //
  7420. // RegistryAllocateHandleResponse_result
  7421. //
  7422.  
  7423. GCC_RegistryAllocateHandleResponse_result::GCC_RegistryAllocateHandleResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  7424.   : PASN_Enumeration(tag, tagClass, 1, TRUE
  7425. #ifndef PASN_NOPRINTON
  7426.       , "successful "
  7427.         "noHandlesAvailable "
  7428. #endif
  7429.     )
  7430. {
  7431. }
  7432.  
  7433.  
  7434. GCC_RegistryAllocateHandleResponse_result & GCC_RegistryAllocateHandleResponse_result::operator=(unsigned v)
  7435. {
  7436.   SetValue(v);
  7437.   return *this;
  7438. }
  7439.  
  7440.  
  7441. PObject * GCC_RegistryAllocateHandleResponse_result::Clone() const
  7442. {
  7443. #ifndef PASN_LEANANDMEAN
  7444.   PAssert(IsClass(GCC_RegistryAllocateHandleResponse_result::Class()), PInvalidCast);
  7445. #endif
  7446.   return new GCC_RegistryAllocateHandleResponse_result(*this);
  7447. }
  7448.  
  7449.  
  7450. //
  7451. // RegistryResponse_primitiveType
  7452. //
  7453.  
  7454. GCC_RegistryResponse_primitiveType::GCC_RegistryResponse_primitiveType(unsigned tag, PASN_Object::TagClass tagClass)
  7455.   : PASN_Enumeration(tag, tagClass, 5, TRUE
  7456. #ifndef PASN_NOPRINTON
  7457.       , "registerChannel "
  7458.         "assignToken "
  7459.         "setParameter "
  7460.         "retrieveEntry "
  7461.         "deleteEntry "
  7462.         "monitorEntry "
  7463. #endif
  7464.     )
  7465. {
  7466. }
  7467.  
  7468.  
  7469. GCC_RegistryResponse_primitiveType & GCC_RegistryResponse_primitiveType::operator=(unsigned v)
  7470. {
  7471.   SetValue(v);
  7472.   return *this;
  7473. }
  7474.  
  7475.  
  7476. PObject * GCC_RegistryResponse_primitiveType::Clone() const
  7477. {
  7478. #ifndef PASN_LEANANDMEAN
  7479.   PAssert(IsClass(GCC_RegistryResponse_primitiveType::Class()), PInvalidCast);
  7480. #endif
  7481.   return new GCC_RegistryResponse_primitiveType(*this);
  7482. }
  7483.  
  7484.  
  7485. //
  7486. // RegistryResponse_result
  7487. //
  7488.  
  7489. GCC_RegistryResponse_result::GCC_RegistryResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  7490.   : PASN_Enumeration(tag, tagClass, 6, TRUE
  7491. #ifndef PASN_NOPRINTON
  7492.       , "successful "
  7493.         "belongsToOther "
  7494.         "tooManyEntries "
  7495.         "inconsistentType "
  7496.         "entryNotFound "
  7497.         "entryAlreadyExists "
  7498.         "invalidRequester "
  7499. #endif
  7500.     )
  7501. {
  7502. }
  7503.  
  7504.  
  7505. GCC_RegistryResponse_result & GCC_RegistryResponse_result::operator=(unsigned v)
  7506. {
  7507.   SetValue(v);
  7508.   return *this;
  7509. }
  7510.  
  7511.  
  7512. PObject * GCC_RegistryResponse_result::Clone() const
  7513. {
  7514. #ifndef PASN_LEANANDMEAN
  7515.   PAssert(IsClass(GCC_RegistryResponse_result::Class()), PInvalidCast);
  7516. #endif
  7517.   return new GCC_RegistryResponse_result(*this);
  7518. }
  7519.  
  7520.  
  7521. //
  7522. // NetworkAddress_subtype_transportConnection
  7523. //
  7524.  
  7525. GCC_NetworkAddress_subtype_transportConnection::GCC_NetworkAddress_subtype_transportConnection(unsigned tag, PASN_Object::TagClass tagClass)
  7526.   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
  7527. {
  7528.   m_nsapAddress.SetConstraints(PASN_Object::FixedConstraint, 1, 20);
  7529. }
  7530.  
  7531.  
  7532. #ifndef PASN_NOPRINTON
  7533. void GCC_NetworkAddress_subtype_transportConnection::PrintOn(ostream & strm) const
  7534. {
  7535.   int indent = strm.precision() + 2;
  7536.   strm << "{\n";
  7537.   strm << setw(indent+14) << "nsapAddress = " << setprecision(indent) << m_nsapAddress << '\n';
  7538.   if (HasOptionalField(e_transportSelector))
  7539.     strm << setw(indent+20) << "transportSelector = " << setprecision(indent) << m_transportSelector << '\n';
  7540.   strm << setw(indent-1) << "}";
  7541. }
  7542. #endif
  7543.  
  7544.  
  7545. PObject::Comparison GCC_NetworkAddress_subtype_transportConnection::Compare(const PObject & obj) const
  7546. {
  7547. #ifndef PASN_LEANANDMEAN
  7548.   PAssert(IsDescendant(GCC_NetworkAddress_subtype_transportConnection::Class()), PInvalidCast);
  7549. #endif
  7550.   const GCC_NetworkAddress_subtype_transportConnection & other = (const GCC_NetworkAddress_subtype_transportConnection &)obj;
  7551.  
  7552.   Comparison result;
  7553.  
  7554.   if ((result = m_nsapAddress.Compare(other.m_nsapAddress)) != EqualTo)
  7555.     return result;
  7556.   if ((result = m_transportSelector.Compare(other.m_transportSelector)) != EqualTo)
  7557.     return result;
  7558.  
  7559.   return PASN_Sequence::Compare(other);
  7560. }
  7561.  
  7562.  
  7563. PINDEX GCC_NetworkAddress_subtype_transportConnection::GetDataLength() const
  7564. {
  7565.   PINDEX length = 0;
  7566.   length += m_nsapAddress.GetObjectLength();
  7567.   if (HasOptionalField(e_transportSelector))
  7568.     length += m_transportSelector.GetObjectLength();
  7569.   return length;
  7570. }
  7571.  
  7572.  
  7573. BOOL GCC_NetworkAddress_subtype_transportConnection::Decode(PASN_Stream & strm)
  7574. {
  7575.   if (!PreambleDecode(strm))
  7576.     return FALSE;
  7577.  
  7578.   if (!m_nsapAddress.Decode(strm))
  7579.     return FALSE;
  7580.   if (HasOptionalField(e_transportSelector) && !m_transportSelector.Decode(strm))
  7581.     return FALSE;
  7582.  
  7583.   return UnknownExtensionsDecode(strm);
  7584. }
  7585.  
  7586.  
  7587. void GCC_NetworkAddress_subtype_transportConnection::Encode(PASN_Stream & strm) const
  7588. {
  7589.   PreambleEncode(strm);
  7590.  
  7591.   m_nsapAddress.Encode(strm);
  7592.   if (HasOptionalField(e_transportSelector))
  7593.     m_transportSelector.Encode(strm);
  7594.  
  7595.   UnknownExtensionsEncode(strm);
  7596. }
  7597.  
  7598.  
  7599. PObject * GCC_NetworkAddress_subtype_transportConnection::Clone() const
  7600. {
  7601. #ifndef PASN_LEANANDMEAN
  7602.   PAssert(IsClass(GCC_NetworkAddress_subtype_transportConnection::Class()), PInvalidCast);
  7603. #endif
  7604.   return new GCC_NetworkAddress_subtype_transportConnection(*this);
  7605. }
  7606.  
  7607.  
  7608. //
  7609. // ApplicationRecord_nonCollapsingCapabilities_subtype
  7610. //
  7611.  
  7612. GCC_ApplicationRecord_nonCollapsingCapabilities_subtype::GCC_ApplicationRecord_nonCollapsingCapabilities_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  7613.   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
  7614. {
  7615. }
  7616.  
  7617.  
  7618. #ifndef PASN_NOPRINTON
  7619. void GCC_ApplicationRecord_nonCollapsingCapabilities_subtype::PrintOn(ostream & strm) const
  7620. {
  7621.   int indent = strm.precision() + 2;
  7622.   strm << "{\n";
  7623.   strm << setw(indent+15) << "capabilityID = " << setprecision(indent) << m_capabilityID << '\n';
  7624.   if (HasOptionalField(e_applicationData))
  7625.     strm << setw(indent+18) << "applicationData = " << setprecision(indent) << m_applicationData << '\n';
  7626.   strm << setw(indent-1) << "}";
  7627. }
  7628. #endif
  7629.  
  7630.  
  7631. PObject::Comparison GCC_ApplicationRecord_nonCollapsingCapabilities_subtype::Compare(const PObject & obj) const
  7632. {
  7633. #ifndef PASN_LEANANDMEAN
  7634.   PAssert(IsDescendant(GCC_ApplicationRecord_nonCollapsingCapabilities_subtype::Class()), PInvalidCast);
  7635. #endif
  7636.   const GCC_ApplicationRecord_nonCollapsingCapabilities_subtype & other = (const GCC_ApplicationRecord_nonCollapsingCapabilities_subtype &)obj;
  7637.  
  7638.   Comparison result;
  7639.  
  7640.   if ((result = m_capabilityID.Compare(other.m_capabilityID)) != EqualTo)
  7641.     return result;
  7642.   if ((result = m_applicationData.Compare(other.m_applicationData)) != EqualTo)
  7643.     return result;
  7644.  
  7645.   return PASN_Sequence::Compare(other);
  7646. }
  7647.  
  7648.  
  7649. PINDEX GCC_ApplicationRecord_nonCollapsingCapabilities_subtype::GetDataLength() const
  7650. {
  7651.   PINDEX length = 0;
  7652.   length += m_capabilityID.GetObjectLength();
  7653.   if (HasOptionalField(e_applicationData))
  7654.     length += m_applicationData.GetObjectLength();
  7655.   return length;
  7656. }
  7657.  
  7658.  
  7659. BOOL GCC_ApplicationRecord_nonCollapsingCapabilities_subtype::Decode(PASN_Stream & strm)
  7660. {
  7661.   if (!PreambleDecode(strm))
  7662.     return FALSE;
  7663.  
  7664.   if (!m_capabilityID.Decode(strm))
  7665.     return FALSE;
  7666.   if (HasOptionalField(e_applicationData) && !m_applicationData.Decode(strm))
  7667.     return FALSE;
  7668.  
  7669.   return UnknownExtensionsDecode(strm);
  7670. }
  7671.  
  7672.  
  7673. void GCC_ApplicationRecord_nonCollapsingCapabilities_subtype::Encode(PASN_Stream & strm) const
  7674. {
  7675.   PreambleEncode(strm);
  7676.  
  7677.   m_capabilityID.Encode(strm);
  7678.   if (HasOptionalField(e_applicationData))
  7679.     m_applicationData.Encode(strm);
  7680.  
  7681.   UnknownExtensionsEncode(strm);
  7682. }
  7683.  
  7684.  
  7685. PObject * GCC_ApplicationRecord_nonCollapsingCapabilities_subtype::Clone() const
  7686. {
  7687. #ifndef PASN_LEANANDMEAN
  7688.   PAssert(IsClass(GCC_ApplicationRecord_nonCollapsingCapabilities_subtype::Class()), PInvalidCast);
  7689. #endif
  7690.   return new GCC_ApplicationRecord_nonCollapsingCapabilities_subtype(*this);
  7691. }
  7692.  
  7693.  
  7694. //
  7695. // ApplicationInvokeSpecifier_expectedCapabilitySet_subtype
  7696. //
  7697.  
  7698. GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype::GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  7699.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  7700. {
  7701. }
  7702.  
  7703.  
  7704. #ifndef PASN_NOPRINTON
  7705. void GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype::PrintOn(ostream & strm) const
  7706. {
  7707.   int indent = strm.precision() + 2;
  7708.   strm << "{\n";
  7709.   strm << setw(indent+15) << "capabilityID = " << setprecision(indent) << m_capabilityID << '\n';
  7710.   strm << setw(indent+18) << "capabilityClass = " << setprecision(indent) << m_capabilityClass << '\n';
  7711.   strm << setw(indent-1) << "}";
  7712. }
  7713. #endif
  7714.  
  7715.  
  7716. PObject::Comparison GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype::Compare(const PObject & obj) const
  7717. {
  7718. #ifndef PASN_LEANANDMEAN
  7719.   PAssert(IsDescendant(GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype::Class()), PInvalidCast);
  7720. #endif
  7721.   const GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype & other = (const GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype &)obj;
  7722.  
  7723.   Comparison result;
  7724.  
  7725.   if ((result = m_capabilityID.Compare(other.m_capabilityID)) != EqualTo)
  7726.     return result;
  7727.   if ((result = m_capabilityClass.Compare(other.m_capabilityClass)) != EqualTo)
  7728.     return result;
  7729.  
  7730.   return PASN_Sequence::Compare(other);
  7731. }
  7732.  
  7733.  
  7734. PINDEX GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype::GetDataLength() const
  7735. {
  7736.   PINDEX length = 0;
  7737.   length += m_capabilityID.GetObjectLength();
  7738.   length += m_capabilityClass.GetObjectLength();
  7739.   return length;
  7740. }
  7741.  
  7742.  
  7743. BOOL GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype::Decode(PASN_Stream & strm)
  7744. {
  7745.   if (!PreambleDecode(strm))
  7746.     return FALSE;
  7747.  
  7748.   if (!m_capabilityID.Decode(strm))
  7749.     return FALSE;
  7750.   if (!m_capabilityClass.Decode(strm))
  7751.     return FALSE;
  7752.  
  7753.   return UnknownExtensionsDecode(strm);
  7754. }
  7755.  
  7756.  
  7757. void GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype::Encode(PASN_Stream & strm) const
  7758. {
  7759.   PreambleEncode(strm);
  7760.  
  7761.   m_capabilityID.Encode(strm);
  7762.   m_capabilityClass.Encode(strm);
  7763.  
  7764.   UnknownExtensionsEncode(strm);
  7765. }
  7766.  
  7767.  
  7768. PObject * GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype::Clone() const
  7769. {
  7770. #ifndef PASN_LEANANDMEAN
  7771.   PAssert(IsClass(GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype::Class()), PInvalidCast);
  7772. #endif
  7773.   return new GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype(*this);
  7774. }
  7775.  
  7776.  
  7777. //
  7778. // RosterUpdateIndication_nodeInformation_nodeRecordList
  7779. //
  7780.  
  7781. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::GCC_RosterUpdateIndication_nodeInformation_nodeRecordList(unsigned tag, PASN_Object::TagClass tagClass)
  7782.   : PASN_Choice(tag, tagClass, 3, TRUE
  7783. #ifndef PASN_NOPRINTON
  7784.       , "noChange "
  7785.         "refresh "
  7786.         "update "
  7787. #endif
  7788.     )
  7789. {
  7790. }
  7791.  
  7792.  
  7793. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  7794. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &() const
  7795. #else
  7796. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &()
  7797. {
  7798. #ifndef PASN_LEANANDMEAN
  7799.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh::Class()), PInvalidCast);
  7800. #endif
  7801.   return *(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh *)choice;
  7802. }
  7803.  
  7804.  
  7805. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::operator const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &() const
  7806. #endif
  7807. {
  7808. #ifndef PASN_LEANANDMEAN
  7809.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh::Class()), PInvalidCast);
  7810. #endif
  7811.   return *(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh *)choice;
  7812. }
  7813.  
  7814.  
  7815. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  7816. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &() const
  7817. #else
  7818. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &()
  7819. {
  7820. #ifndef PASN_LEANANDMEAN
  7821.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update::Class()), PInvalidCast);
  7822. #endif
  7823.   return *(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update *)choice;
  7824. }
  7825.  
  7826.  
  7827. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::operator const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &() const
  7828. #endif
  7829. {
  7830. #ifndef PASN_LEANANDMEAN
  7831.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update::Class()), PInvalidCast);
  7832. #endif
  7833.   return *(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update *)choice;
  7834. }
  7835.  
  7836.  
  7837. BOOL GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::CreateObject()
  7838. {
  7839.   switch (tag) {
  7840.     case e_noChange :
  7841.       choice = new PASN_Null();
  7842.       return TRUE;
  7843.     case e_refresh :
  7844.       choice = new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh();
  7845.       return TRUE;
  7846.     case e_update :
  7847.       choice = new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update();
  7848.       return TRUE;
  7849.   }
  7850.  
  7851.   choice = NULL;
  7852.   return FALSE;
  7853. }
  7854.  
  7855.  
  7856. PObject * GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::Clone() const
  7857. {
  7858. #ifndef PASN_LEANANDMEAN
  7859.   PAssert(IsClass(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList::Class()), PInvalidCast);
  7860. #endif
  7861.   return new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList(*this);
  7862. }
  7863.  
  7864.  
  7865. //
  7866. // NetworkAddress_subtype_aggregatedChannel_transferModes
  7867. //
  7868.  
  7869. GCC_NetworkAddress_subtype_aggregatedChannel_transferModes::GCC_NetworkAddress_subtype_aggregatedChannel_transferModes(unsigned tag, PASN_Object::TagClass tagClass)
  7870.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  7871. {
  7872. }
  7873.  
  7874.  
  7875. #ifndef PASN_NOPRINTON
  7876. void GCC_NetworkAddress_subtype_aggregatedChannel_transferModes::PrintOn(ostream & strm) const
  7877. {
  7878.   int indent = strm.precision() + 2;
  7879.   strm << "{\n";
  7880.   strm << setw(indent+9) << "speech = " << setprecision(indent) << m_speech << '\n';
  7881.   strm << setw(indent+13) << "voice_band = " << setprecision(indent) << m_voice_band << '\n';
  7882.   strm << setw(indent+14) << "digital_56k = " << setprecision(indent) << m_digital_56k << '\n';
  7883.   strm << setw(indent+14) << "digital_64k = " << setprecision(indent) << m_digital_64k << '\n';
  7884.   strm << setw(indent+15) << "digital_128k = " << setprecision(indent) << m_digital_128k << '\n';
  7885.   strm << setw(indent+15) << "digital_192k = " << setprecision(indent) << m_digital_192k << '\n';
  7886.   strm << setw(indent+15) << "digital_256k = " << setprecision(indent) << m_digital_256k << '\n';
  7887.   strm << setw(indent+15) << "digital_320k = " << setprecision(indent) << m_digital_320k << '\n';
  7888.   strm << setw(indent+15) << "digital_384k = " << setprecision(indent) << m_digital_384k << '\n';
  7889.   strm << setw(indent+15) << "digital_512k = " << setprecision(indent) << m_digital_512k << '\n';
  7890.   strm << setw(indent+15) << "digital_768k = " << setprecision(indent) << m_digital_768k << '\n';
  7891.   strm << setw(indent+16) << "digital_1152k = " << setprecision(indent) << m_digital_1152k << '\n';
  7892.   strm << setw(indent+16) << "digital_1472k = " << setprecision(indent) << m_digital_1472k << '\n';
  7893.   strm << setw(indent+16) << "digital_1536k = " << setprecision(indent) << m_digital_1536k << '\n';
  7894.   strm << setw(indent+16) << "digital_1920k = " << setprecision(indent) << m_digital_1920k << '\n';
  7895.   strm << setw(indent+14) << "packet_mode = " << setprecision(indent) << m_packet_mode << '\n';
  7896.   strm << setw(indent+13) << "frame_mode = " << setprecision(indent) << m_frame_mode << '\n';
  7897.   strm << setw(indent+6) << "atm = " << setprecision(indent) << m_atm << '\n';
  7898.   strm << setw(indent-1) << "}";
  7899. }
  7900. #endif
  7901.  
  7902.  
  7903. PObject::Comparison GCC_NetworkAddress_subtype_aggregatedChannel_transferModes::Compare(const PObject & obj) const
  7904. {
  7905. #ifndef PASN_LEANANDMEAN
  7906.   PAssert(IsDescendant(GCC_NetworkAddress_subtype_aggregatedChannel_transferModes::Class()), PInvalidCast);
  7907. #endif
  7908.   const GCC_NetworkAddress_subtype_aggregatedChannel_transferModes & other = (const GCC_NetworkAddress_subtype_aggregatedChannel_transferModes &)obj;
  7909.  
  7910.   Comparison result;
  7911.  
  7912.   if ((result = m_speech.Compare(other.m_speech)) != EqualTo)
  7913.     return result;
  7914.   if ((result = m_voice_band.Compare(other.m_voice_band)) != EqualTo)
  7915.     return result;
  7916.   if ((result = m_digital_56k.Compare(other.m_digital_56k)) != EqualTo)
  7917.     return result;
  7918.   if ((result = m_digital_64k.Compare(other.m_digital_64k)) != EqualTo)
  7919.     return result;
  7920.   if ((result = m_digital_128k.Compare(other.m_digital_128k)) != EqualTo)
  7921.     return result;
  7922.   if ((result = m_digital_192k.Compare(other.m_digital_192k)) != EqualTo)
  7923.     return result;
  7924.   if ((result = m_digital_256k.Compare(other.m_digital_256k)) != EqualTo)
  7925.     return result;
  7926.   if ((result = m_digital_320k.Compare(other.m_digital_320k)) != EqualTo)
  7927.     return result;
  7928.   if ((result = m_digital_384k.Compare(other.m_digital_384k)) != EqualTo)
  7929.     return result;
  7930.   if ((result = m_digital_512k.Compare(other.m_digital_512k)) != EqualTo)
  7931.     return result;
  7932.   if ((result = m_digital_768k.Compare(other.m_digital_768k)) != EqualTo)
  7933.     return result;
  7934.   if ((result = m_digital_1152k.Compare(other.m_digital_1152k)) != EqualTo)
  7935.     return result;
  7936.   if ((result = m_digital_1472k.Compare(other.m_digital_1472k)) != EqualTo)
  7937.     return result;
  7938.   if ((result = m_digital_1536k.Compare(other.m_digital_1536k)) != EqualTo)
  7939.     return result;
  7940.   if ((result = m_digital_1920k.Compare(other.m_digital_1920k)) != EqualTo)
  7941.     return result;
  7942.   if ((result = m_packet_mode.Compare(other.m_packet_mode)) != EqualTo)
  7943.     return result;
  7944.   if ((result = m_frame_mode.Compare(other.m_frame_mode)) != EqualTo)
  7945.     return result;
  7946.   if ((result = m_atm.Compare(other.m_atm)) != EqualTo)
  7947.     return result;
  7948.  
  7949.   return PASN_Sequence::Compare(other);
  7950. }
  7951.  
  7952.  
  7953. PINDEX GCC_NetworkAddress_subtype_aggregatedChannel_transferModes::GetDataLength() const
  7954. {
  7955.   PINDEX length = 0;
  7956.   length += m_speech.GetObjectLength();
  7957.   length += m_voice_band.GetObjectLength();
  7958.   length += m_digital_56k.GetObjectLength();
  7959.   length += m_digital_64k.GetObjectLength();
  7960.   length += m_digital_128k.GetObjectLength();
  7961.   length += m_digital_192k.GetObjectLength();
  7962.   length += m_digital_256k.GetObjectLength();
  7963.   length += m_digital_320k.GetObjectLength();
  7964.   length += m_digital_384k.GetObjectLength();
  7965.   length += m_digital_512k.GetObjectLength();
  7966.   length += m_digital_768k.GetObjectLength();
  7967.   length += m_digital_1152k.GetObjectLength();
  7968.   length += m_digital_1472k.GetObjectLength();
  7969.   length += m_digital_1536k.GetObjectLength();
  7970.   length += m_digital_1920k.GetObjectLength();
  7971.   length += m_packet_mode.GetObjectLength();
  7972.   length += m_frame_mode.GetObjectLength();
  7973.   length += m_atm.GetObjectLength();
  7974.   return length;
  7975. }
  7976.  
  7977.  
  7978. BOOL GCC_NetworkAddress_subtype_aggregatedChannel_transferModes::Decode(PASN_Stream & strm)
  7979. {
  7980.   if (!PreambleDecode(strm))
  7981.     return FALSE;
  7982.  
  7983.   if (!m_speech.Decode(strm))
  7984.     return FALSE;
  7985.   if (!m_voice_band.Decode(strm))
  7986.     return FALSE;
  7987.   if (!m_digital_56k.Decode(strm))
  7988.     return FALSE;
  7989.   if (!m_digital_64k.Decode(strm))
  7990.     return FALSE;
  7991.   if (!m_digital_128k.Decode(strm))
  7992.     return FALSE;
  7993.   if (!m_digital_192k.Decode(strm))
  7994.     return FALSE;
  7995.   if (!m_digital_256k.Decode(strm))
  7996.     return FALSE;
  7997.   if (!m_digital_320k.Decode(strm))
  7998.     return FALSE;
  7999.   if (!m_digital_384k.Decode(strm))
  8000.     return FALSE;
  8001.   if (!m_digital_512k.Decode(strm))
  8002.     return FALSE;
  8003.   if (!m_digital_768k.Decode(strm))
  8004.     return FALSE;
  8005.   if (!m_digital_1152k.Decode(strm))
  8006.     return FALSE;
  8007.   if (!m_digital_1472k.Decode(strm))
  8008.     return FALSE;
  8009.   if (!m_digital_1536k.Decode(strm))
  8010.     return FALSE;
  8011.   if (!m_digital_1920k.Decode(strm))
  8012.     return FALSE;
  8013.   if (!m_packet_mode.Decode(strm))
  8014.     return FALSE;
  8015.   if (!m_frame_mode.Decode(strm))
  8016.     return FALSE;
  8017.   if (!m_atm.Decode(strm))
  8018.     return FALSE;
  8019.  
  8020.   return UnknownExtensionsDecode(strm);
  8021. }
  8022.  
  8023.  
  8024. void GCC_NetworkAddress_subtype_aggregatedChannel_transferModes::Encode(PASN_Stream & strm) const
  8025. {
  8026.   PreambleEncode(strm);
  8027.  
  8028.   m_speech.Encode(strm);
  8029.   m_voice_band.Encode(strm);
  8030.   m_digital_56k.Encode(strm);
  8031.   m_digital_64k.Encode(strm);
  8032.   m_digital_128k.Encode(strm);
  8033.   m_digital_192k.Encode(strm);
  8034.   m_digital_256k.Encode(strm);
  8035.   m_digital_320k.Encode(strm);
  8036.   m_digital_384k.Encode(strm);
  8037.   m_digital_512k.Encode(strm);
  8038.   m_digital_768k.Encode(strm);
  8039.   m_digital_1152k.Encode(strm);
  8040.   m_digital_1472k.Encode(strm);
  8041.   m_digital_1536k.Encode(strm);
  8042.   m_digital_1920k.Encode(strm);
  8043.   m_packet_mode.Encode(strm);
  8044.   m_frame_mode.Encode(strm);
  8045.   m_atm.Encode(strm);
  8046.  
  8047.   UnknownExtensionsEncode(strm);
  8048. }
  8049.  
  8050.  
  8051. PObject * GCC_NetworkAddress_subtype_aggregatedChannel_transferModes::Clone() const
  8052. {
  8053. #ifndef PASN_LEANANDMEAN
  8054.   PAssert(IsClass(GCC_NetworkAddress_subtype_aggregatedChannel_transferModes::Class()), PInvalidCast);
  8055. #endif
  8056.   return new GCC_NetworkAddress_subtype_aggregatedChannel_transferModes(*this);
  8057. }
  8058.  
  8059.  
  8060. //
  8061. // NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility
  8062. //
  8063.  
  8064. GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility::GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility(unsigned tag, PASN_Object::TagClass tagClass)
  8065.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  8066. {
  8067. }
  8068.  
  8069.  
  8070. #ifndef PASN_NOPRINTON
  8071. void GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility::PrintOn(ostream & strm) const
  8072. {
  8073.   int indent = strm.precision() + 2;
  8074.   strm << "{\n";
  8075.   strm << setw(indent+16) << "telephony3kHz = " << setprecision(indent) << m_telephony3kHz << '\n';
  8076.   strm << setw(indent+16) << "telephony7kHz = " << setprecision(indent) << m_telephony7kHz << '\n';
  8077.   strm << setw(indent+17) << "videotelephony = " << setprecision(indent) << m_videotelephony << '\n';
  8078.   strm << setw(indent+18) << "videoconference = " << setprecision(indent) << m_videoconference << '\n';
  8079.   strm << setw(indent+15) << "audiographic = " << setprecision(indent) << m_audiographic << '\n';
  8080.   strm << setw(indent+14) << "audiovisual = " << setprecision(indent) << m_audiovisual << '\n';
  8081.   strm << setw(indent+13) << "multimedia = " << setprecision(indent) << m_multimedia << '\n';
  8082.   strm << setw(indent-1) << "}";
  8083. }
  8084. #endif
  8085.  
  8086.  
  8087. PObject::Comparison GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility::Compare(const PObject & obj) const
  8088. {
  8089. #ifndef PASN_LEANANDMEAN
  8090.   PAssert(IsDescendant(GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility::Class()), PInvalidCast);
  8091. #endif
  8092.   const GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility & other = (const GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility &)obj;
  8093.  
  8094.   Comparison result;
  8095.  
  8096.   if ((result = m_telephony3kHz.Compare(other.m_telephony3kHz)) != EqualTo)
  8097.     return result;
  8098.   if ((result = m_telephony7kHz.Compare(other.m_telephony7kHz)) != EqualTo)
  8099.     return result;
  8100.   if ((result = m_videotelephony.Compare(other.m_videotelephony)) != EqualTo)
  8101.     return result;
  8102.   if ((result = m_videoconference.Compare(other.m_videoconference)) != EqualTo)
  8103.     return result;
  8104.   if ((result = m_audiographic.Compare(other.m_audiographic)) != EqualTo)
  8105.     return result;
  8106.   if ((result = m_audiovisual.Compare(other.m_audiovisual)) != EqualTo)
  8107.     return result;
  8108.   if ((result = m_multimedia.Compare(other.m_multimedia)) != EqualTo)
  8109.     return result;
  8110.  
  8111.   return PASN_Sequence::Compare(other);
  8112. }
  8113.  
  8114.  
  8115. PINDEX GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility::GetDataLength() const
  8116. {
  8117.   PINDEX length = 0;
  8118.   length += m_telephony3kHz.GetObjectLength();
  8119.   length += m_telephony7kHz.GetObjectLength();
  8120.   length += m_videotelephony.GetObjectLength();
  8121.   length += m_videoconference.GetObjectLength();
  8122.   length += m_audiographic.GetObjectLength();
  8123.   length += m_audiovisual.GetObjectLength();
  8124.   length += m_multimedia.GetObjectLength();
  8125.   return length;
  8126. }
  8127.  
  8128.  
  8129. BOOL GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility::Decode(PASN_Stream & strm)
  8130. {
  8131.   if (!PreambleDecode(strm))
  8132.     return FALSE;
  8133.  
  8134.   if (!m_telephony3kHz.Decode(strm))
  8135.     return FALSE;
  8136.   if (!m_telephony7kHz.Decode(strm))
  8137.     return FALSE;
  8138.   if (!m_videotelephony.Decode(strm))
  8139.     return FALSE;
  8140.   if (!m_videoconference.Decode(strm))
  8141.     return FALSE;
  8142.   if (!m_audiographic.Decode(strm))
  8143.     return FALSE;
  8144.   if (!m_audiovisual.Decode(strm))
  8145.     return FALSE;
  8146.   if (!m_multimedia.Decode(strm))
  8147.     return FALSE;
  8148.  
  8149.   return UnknownExtensionsDecode(strm);
  8150. }
  8151.  
  8152.  
  8153. void GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility::Encode(PASN_Stream & strm) const
  8154. {
  8155.   PreambleEncode(strm);
  8156.  
  8157.   m_telephony3kHz.Encode(strm);
  8158.   m_telephony7kHz.Encode(strm);
  8159.   m_videotelephony.Encode(strm);
  8160.   m_videoconference.Encode(strm);
  8161.   m_audiographic.Encode(strm);
  8162.   m_audiovisual.Encode(strm);
  8163.   m_multimedia.Encode(strm);
  8164.  
  8165.   UnknownExtensionsEncode(strm);
  8166. }
  8167.  
  8168.  
  8169. PObject * GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility::Clone() const
  8170. {
  8171. #ifndef PASN_LEANANDMEAN
  8172.   PAssert(IsClass(GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility::Class()), PInvalidCast);
  8173. #endif
  8174.   return new GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility(*this);
  8175. }
  8176.  
  8177.  
  8178. //
  8179. // RosterUpdateIndication_nodeInformation_nodeRecordList_refresh
  8180. //
  8181.  
  8182. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh::GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh(unsigned tag, PASN_Object::TagClass tagClass)
  8183.   : PASN_Array(tag, tagClass)
  8184. {
  8185.   SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  8186. }
  8187.  
  8188.  
  8189. PASN_Object * GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh::CreateObject() const
  8190. {
  8191.   return new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype;
  8192. }
  8193.  
  8194.  
  8195. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype & GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh::operator[](PINDEX i) const
  8196. {
  8197.   return (GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype &)array[i];
  8198. }
  8199.  
  8200.  
  8201. PObject * GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh::Clone() const
  8202. {
  8203. #ifndef PASN_LEANANDMEAN
  8204.   PAssert(IsClass(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh::Class()), PInvalidCast);
  8205. #endif
  8206.   return new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh(*this);
  8207. }
  8208.  
  8209.  
  8210. //
  8211. // RosterUpdateIndication_nodeInformation_nodeRecordList_update
  8212. //
  8213.  
  8214. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update::GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update(unsigned tag, PASN_Object::TagClass tagClass)
  8215.   : PASN_Array(tag, tagClass)
  8216. {
  8217.   SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  8218. }
  8219.  
  8220.  
  8221. PASN_Object * GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update::CreateObject() const
  8222. {
  8223.   return new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype;
  8224. }
  8225.  
  8226.  
  8227. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype & GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update::operator[](PINDEX i) const
  8228. {
  8229.   return (GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype &)array[i];
  8230. }
  8231.  
  8232.  
  8233. PObject * GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update::Clone() const
  8234. {
  8235. #ifndef PASN_LEANANDMEAN
  8236.   PAssert(IsClass(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update::Class()), PInvalidCast);
  8237. #endif
  8238.   return new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update(*this);
  8239. }
  8240.  
  8241.  
  8242. //
  8243. // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList
  8244. //
  8245.  
  8246. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList(unsigned tag, PASN_Object::TagClass tagClass)
  8247.   : PASN_Choice(tag, tagClass, 3, TRUE
  8248. #ifndef PASN_NOPRINTON
  8249.       , "noChange "
  8250.         "refresh "
  8251.         "update "
  8252. #endif
  8253.     )
  8254. {
  8255. }
  8256.  
  8257.  
  8258. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  8259. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &() const
  8260. #else
  8261. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &()
  8262. {
  8263. #ifndef PASN_LEANANDMEAN
  8264.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh::Class()), PInvalidCast);
  8265. #endif
  8266.   return *(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh *)choice;
  8267. }
  8268.  
  8269.  
  8270. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &() const
  8271. #endif
  8272. {
  8273. #ifndef PASN_LEANANDMEAN
  8274.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh::Class()), PInvalidCast);
  8275. #endif
  8276.   return *(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh *)choice;
  8277. }
  8278.  
  8279.  
  8280. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  8281. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &() const
  8282. #else
  8283. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &()
  8284. {
  8285. #ifndef PASN_LEANANDMEAN
  8286.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update::Class()), PInvalidCast);
  8287. #endif
  8288.   return *(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update *)choice;
  8289. }
  8290.  
  8291.  
  8292. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &() const
  8293. #endif
  8294. {
  8295. #ifndef PASN_LEANANDMEAN
  8296.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update::Class()), PInvalidCast);
  8297. #endif
  8298.   return *(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update *)choice;
  8299. }
  8300.  
  8301.  
  8302. BOOL GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::CreateObject()
  8303. {
  8304.   switch (tag) {
  8305.     case e_noChange :
  8306.       choice = new PASN_Null();
  8307.       return TRUE;
  8308.     case e_refresh :
  8309.       choice = new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh();
  8310.       return TRUE;
  8311.     case e_update :
  8312.       choice = new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update();
  8313.       return TRUE;
  8314.   }
  8315.  
  8316.   choice = NULL;
  8317.   return FALSE;
  8318. }
  8319.  
  8320.  
  8321. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::Clone() const
  8322. {
  8323. #ifndef PASN_LEANANDMEAN
  8324.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList::Class()), PInvalidCast);
  8325. #endif
  8326.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList(*this);
  8327. }
  8328.  
  8329.  
  8330. //
  8331. // RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList
  8332. //
  8333.  
  8334. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList::GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList(unsigned tag, PASN_Object::TagClass tagClass)
  8335.   : PASN_Choice(tag, tagClass, 2, TRUE
  8336. #ifndef PASN_NOPRINTON
  8337.       , "noChange "
  8338.         "refresh "
  8339. #endif
  8340.     )
  8341. {
  8342. }
  8343.  
  8344.  
  8345. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  8346. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList::operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &() const
  8347. #else
  8348. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList::operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &()
  8349. {
  8350. #ifndef PASN_LEANANDMEAN
  8351.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh::Class()), PInvalidCast);
  8352. #endif
  8353.   return *(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh *)choice;
  8354. }
  8355.  
  8356.  
  8357. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList::operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &() const
  8358. #endif
  8359. {
  8360. #ifndef PASN_LEANANDMEAN
  8361.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh::Class()), PInvalidCast);
  8362. #endif
  8363.   return *(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh *)choice;
  8364. }
  8365.  
  8366.  
  8367. BOOL GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList::CreateObject()
  8368. {
  8369.   switch (tag) {
  8370.     case e_noChange :
  8371.       choice = new PASN_Null();
  8372.       return TRUE;
  8373.     case e_refresh :
  8374.       choice = new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh();
  8375.       return TRUE;
  8376.   }
  8377.  
  8378.   choice = NULL;
  8379.   return FALSE;
  8380. }
  8381.  
  8382.  
  8383. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList::Clone() const
  8384. {
  8385. #ifndef PASN_LEANANDMEAN
  8386.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList::Class()), PInvalidCast);
  8387. #endif
  8388.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList(*this);
  8389. }
  8390.  
  8391.  
  8392. //
  8393. // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh
  8394. //
  8395.  
  8396. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh::GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh(unsigned tag, PASN_Object::TagClass tagClass)
  8397.   : PASN_Array(tag, tagClass)
  8398. {
  8399.   SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  8400. }
  8401.  
  8402.  
  8403. PASN_Object * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh::CreateObject() const
  8404. {
  8405.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype;
  8406. }
  8407.  
  8408.  
  8409. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype & GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh::operator[](PINDEX i) const
  8410. {
  8411.   return (GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype &)array[i];
  8412. }
  8413.  
  8414.  
  8415. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh::Clone() const
  8416. {
  8417. #ifndef PASN_LEANANDMEAN
  8418.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh::Class()), PInvalidCast);
  8419. #endif
  8420.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh(*this);
  8421. }
  8422.  
  8423.  
  8424. //
  8425. // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update
  8426. //
  8427.  
  8428. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update::GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update(unsigned tag, PASN_Object::TagClass tagClass)
  8429.   : PASN_Array(tag, tagClass)
  8430. {
  8431.   SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  8432. }
  8433.  
  8434.  
  8435. PASN_Object * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update::CreateObject() const
  8436. {
  8437.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype;
  8438. }
  8439.  
  8440.  
  8441. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype & GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update::operator[](PINDEX i) const
  8442. {
  8443.   return (GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype &)array[i];
  8444. }
  8445.  
  8446.  
  8447. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update::Clone() const
  8448. {
  8449. #ifndef PASN_LEANANDMEAN
  8450.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update::Class()), PInvalidCast);
  8451. #endif
  8452.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update(*this);
  8453. }
  8454.  
  8455.  
  8456. //
  8457. // RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh
  8458. //
  8459.  
  8460. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh::GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh(unsigned tag, PASN_Object::TagClass tagClass)
  8461.   : PASN_Array(tag, tagClass)
  8462. {
  8463. }
  8464.  
  8465.  
  8466. PASN_Object * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh::CreateObject() const
  8467. {
  8468.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype;
  8469. }
  8470.  
  8471.  
  8472. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype & GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh::operator[](PINDEX i) const
  8473. {
  8474.   return (GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype &)array[i];
  8475. }
  8476.  
  8477.  
  8478. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh::Clone() const
  8479. {
  8480. #ifndef PASN_LEANANDMEAN
  8481.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh::Class()), PInvalidCast);
  8482. #endif
  8483.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh(*this);
  8484. }
  8485.  
  8486.  
  8487. //
  8488. // RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate
  8489. //
  8490.  
  8491. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate::GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate(unsigned tag, PASN_Object::TagClass tagClass)
  8492.   : PASN_Choice(tag, tagClass, 3, TRUE
  8493. #ifndef PASN_NOPRINTON
  8494.       , "addRecord "
  8495.         "replaceRecord "
  8496.         "removeRecord "
  8497. #endif
  8498.     )
  8499. {
  8500. }
  8501.  
  8502.  
  8503. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  8504. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate::operator GCC_NodeRecord &() const
  8505. #else
  8506. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate::operator GCC_NodeRecord &()
  8507. {
  8508. #ifndef PASN_LEANANDMEAN
  8509.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NodeRecord::Class()), PInvalidCast);
  8510. #endif
  8511.   return *(GCC_NodeRecord *)choice;
  8512. }
  8513.  
  8514.  
  8515. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate::operator const GCC_NodeRecord &() const
  8516. #endif
  8517. {
  8518. #ifndef PASN_LEANANDMEAN
  8519.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_NodeRecord::Class()), PInvalidCast);
  8520. #endif
  8521.   return *(GCC_NodeRecord *)choice;
  8522. }
  8523.  
  8524.  
  8525. BOOL GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate::CreateObject()
  8526. {
  8527.   switch (tag) {
  8528.     case e_addRecord :
  8529.     case e_replaceRecord :
  8530.       choice = new GCC_NodeRecord();
  8531.       return TRUE;
  8532.     case e_removeRecord :
  8533.       choice = new PASN_Null();
  8534.       return TRUE;
  8535.   }
  8536.  
  8537.   choice = NULL;
  8538.   return FALSE;
  8539. }
  8540.  
  8541.  
  8542. PObject * GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate::Clone() const
  8543. {
  8544. #ifndef PASN_LEANANDMEAN
  8545.   PAssert(IsClass(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate::Class()), PInvalidCast);
  8546. #endif
  8547.   return new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate(*this);
  8548. }
  8549.  
  8550.  
  8551. //
  8552. // RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype
  8553. //
  8554.  
  8555. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype::GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  8556.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  8557. {
  8558.   m_numberOfEntities.SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  8559. }
  8560.  
  8561.  
  8562. #ifndef PASN_NOPRINTON
  8563. void GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype::PrintOn(ostream & strm) const
  8564. {
  8565.   int indent = strm.precision() + 2;
  8566.   strm << "{\n";
  8567.   strm << setw(indent+15) << "capabilityID = " << setprecision(indent) << m_capabilityID << '\n';
  8568.   strm << setw(indent+18) << "capabilityClass = " << setprecision(indent) << m_capabilityClass << '\n';
  8569.   strm << setw(indent+19) << "numberOfEntities = " << setprecision(indent) << m_numberOfEntities << '\n';
  8570.   strm << setw(indent-1) << "}";
  8571. }
  8572. #endif
  8573.  
  8574.  
  8575. PObject::Comparison GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype::Compare(const PObject & obj) const
  8576. {
  8577. #ifndef PASN_LEANANDMEAN
  8578.   PAssert(IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype::Class()), PInvalidCast);
  8579. #endif
  8580.   const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype & other = (const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype &)obj;
  8581.  
  8582.   Comparison result;
  8583.  
  8584.   if ((result = m_capabilityID.Compare(other.m_capabilityID)) != EqualTo)
  8585.     return result;
  8586.   if ((result = m_capabilityClass.Compare(other.m_capabilityClass)) != EqualTo)
  8587.     return result;
  8588.   if ((result = m_numberOfEntities.Compare(other.m_numberOfEntities)) != EqualTo)
  8589.     return result;
  8590.  
  8591.   return PASN_Sequence::Compare(other);
  8592. }
  8593.  
  8594.  
  8595. PINDEX GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype::GetDataLength() const
  8596. {
  8597.   PINDEX length = 0;
  8598.   length += m_capabilityID.GetObjectLength();
  8599.   length += m_capabilityClass.GetObjectLength();
  8600.   length += m_numberOfEntities.GetObjectLength();
  8601.   return length;
  8602. }
  8603.  
  8604.  
  8605. BOOL GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype::Decode(PASN_Stream & strm)
  8606. {
  8607.   if (!PreambleDecode(strm))
  8608.     return FALSE;
  8609.  
  8610.   if (!m_capabilityID.Decode(strm))
  8611.     return FALSE;
  8612.   if (!m_capabilityClass.Decode(strm))
  8613.     return FALSE;
  8614.   if (!m_numberOfEntities.Decode(strm))
  8615.     return FALSE;
  8616.  
  8617.   return UnknownExtensionsDecode(strm);
  8618. }
  8619.  
  8620.  
  8621. void GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype::Encode(PASN_Stream & strm) const
  8622. {
  8623.   PreambleEncode(strm);
  8624.  
  8625.   m_capabilityID.Encode(strm);
  8626.   m_capabilityClass.Encode(strm);
  8627.   m_numberOfEntities.Encode(strm);
  8628.  
  8629.   UnknownExtensionsEncode(strm);
  8630. }
  8631.  
  8632.  
  8633. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype::Clone() const
  8634. {
  8635. #ifndef PASN_LEANANDMEAN
  8636.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype::Class()), PInvalidCast);
  8637. #endif
  8638.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype(*this);
  8639. }
  8640.  
  8641.  
  8642. //
  8643. // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate
  8644. //
  8645.  
  8646. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate::GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate(unsigned tag, PASN_Object::TagClass tagClass)
  8647.   : PASN_Choice(tag, tagClass, 3, TRUE
  8648. #ifndef PASN_NOPRINTON
  8649.       , "addRecord "
  8650.         "replaceRecord "
  8651.         "removeRecord "
  8652. #endif
  8653.     )
  8654. {
  8655. }
  8656.  
  8657.  
  8658. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  8659. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate::operator GCC_ApplicationRecord &() const
  8660. #else
  8661. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate::operator GCC_ApplicationRecord &()
  8662. {
  8663. #ifndef PASN_LEANANDMEAN
  8664.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ApplicationRecord::Class()), PInvalidCast);
  8665. #endif
  8666.   return *(GCC_ApplicationRecord *)choice;
  8667. }
  8668.  
  8669.  
  8670. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate::operator const GCC_ApplicationRecord &() const
  8671. #endif
  8672. {
  8673. #ifndef PASN_LEANANDMEAN
  8674.   PAssert(PAssertNULL(choice)->IsDescendant(GCC_ApplicationRecord::Class()), PInvalidCast);
  8675. #endif
  8676.   return *(GCC_ApplicationRecord *)choice;
  8677. }
  8678.  
  8679.  
  8680. BOOL GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate::CreateObject()
  8681. {
  8682.   switch (tag) {
  8683.     case e_addRecord :
  8684.     case e_replaceRecord :
  8685.       choice = new GCC_ApplicationRecord();
  8686.       return TRUE;
  8687.     case e_removeRecord :
  8688.       choice = new PASN_Null();
  8689.       return TRUE;
  8690.   }
  8691.  
  8692.   choice = NULL;
  8693.   return FALSE;
  8694. }
  8695.  
  8696.  
  8697. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate::Clone() const
  8698. {
  8699. #ifndef PASN_LEANANDMEAN
  8700.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate::Class()), PInvalidCast);
  8701. #endif
  8702.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate(*this);
  8703. }
  8704.  
  8705.  
  8706. //
  8707. // ChallengeRequest
  8708. //
  8709.  
  8710. GCC_ChallengeRequest::GCC_ChallengeRequest(unsigned tag, PASN_Object::TagClass tagClass)
  8711.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  8712. {
  8713. }
  8714.  
  8715.  
  8716. #ifndef PASN_NOPRINTON
  8717. void GCC_ChallengeRequest::PrintOn(ostream & strm) const
  8718. {
  8719.   int indent = strm.precision() + 2;
  8720.   strm << "{\n";
  8721.   strm << setw(indent+15) << "challengeTag = " << setprecision(indent) << m_challengeTag << '\n';
  8722.   strm << setw(indent+15) << "challengeSet = " << setprecision(indent) << m_challengeSet << '\n';
  8723.   strm << setw(indent-1) << "}";
  8724. }
  8725. #endif
  8726.  
  8727.  
  8728. PObject::Comparison GCC_ChallengeRequest::Compare(const PObject & obj) const
  8729. {
  8730. #ifndef PASN_LEANANDMEAN
  8731.   PAssert(IsDescendant(GCC_ChallengeRequest::Class()), PInvalidCast);
  8732. #endif
  8733.   const GCC_ChallengeRequest & other = (const GCC_ChallengeRequest &)obj;
  8734.  
  8735.   Comparison result;
  8736.  
  8737.   if ((result = m_challengeTag.Compare(other.m_challengeTag)) != EqualTo)
  8738.     return result;
  8739.   if ((result = m_challengeSet.Compare(other.m_challengeSet)) != EqualTo)
  8740.     return result;
  8741.  
  8742.   return PASN_Sequence::Compare(other);
  8743. }
  8744.  
  8745.  
  8746. PINDEX GCC_ChallengeRequest::GetDataLength() const
  8747. {
  8748.   PINDEX length = 0;
  8749.   length += m_challengeTag.GetObjectLength();
  8750.   length += m_challengeSet.GetObjectLength();
  8751.   return length;
  8752. }
  8753.  
  8754.  
  8755. BOOL GCC_ChallengeRequest::Decode(PASN_Stream & strm)
  8756. {
  8757.   if (!PreambleDecode(strm))
  8758.     return FALSE;
  8759.  
  8760.   if (!m_challengeTag.Decode(strm))
  8761.     return FALSE;
  8762.   if (!m_challengeSet.Decode(strm))
  8763.     return FALSE;
  8764.  
  8765.   return UnknownExtensionsDecode(strm);
  8766. }
  8767.  
  8768.  
  8769. void GCC_ChallengeRequest::Encode(PASN_Stream & strm) const
  8770. {
  8771.   PreambleEncode(strm);
  8772.  
  8773.   m_challengeTag.Encode(strm);
  8774.   m_challengeSet.Encode(strm);
  8775.  
  8776.   UnknownExtensionsEncode(strm);
  8777. }
  8778.  
  8779.  
  8780. PObject * GCC_ChallengeRequest::Clone() const
  8781. {
  8782. #ifndef PASN_LEANANDMEAN
  8783.   PAssert(IsClass(GCC_ChallengeRequest::Class()), PInvalidCast);
  8784. #endif
  8785.   return new GCC_ChallengeRequest(*this);
  8786. }
  8787.  
  8788.  
  8789. //
  8790. // NodeRecord
  8791. //
  8792.  
  8793. GCC_NodeRecord::GCC_NodeRecord(unsigned tag, PASN_Object::TagClass tagClass)
  8794.   : PASN_Sequence(tag, tagClass, 7, TRUE, 0)
  8795. {
  8796. }
  8797.  
  8798.  
  8799. #ifndef PASN_NOPRINTON
  8800. void GCC_NodeRecord::PrintOn(ostream & strm) const
  8801. {
  8802.   int indent = strm.precision() + 2;
  8803.   strm << "{\n";
  8804.   if (HasOptionalField(e_superiorNode))
  8805.     strm << setw(indent+15) << "superiorNode = " << setprecision(indent) << m_superiorNode << '\n';
  8806.   strm << setw(indent+11) << "nodeType = " << setprecision(indent) << m_nodeType << '\n';
  8807.   strm << setw(indent+17) << "nodeProperties = " << setprecision(indent) << m_nodeProperties << '\n';
  8808.   if (HasOptionalField(e_nodeName))
  8809.     strm << setw(indent+11) << "nodeName = " << setprecision(indent) << m_nodeName << '\n';
  8810.   if (HasOptionalField(e_participantsList))
  8811.     strm << setw(indent+19) << "participantsList = " << setprecision(indent) << m_participantsList << '\n';
  8812.   if (HasOptionalField(e_siteInformation))
  8813.     strm << setw(indent+18) << "siteInformation = " << setprecision(indent) << m_siteInformation << '\n';
  8814.   if (HasOptionalField(e_networkAddress))
  8815.     strm << setw(indent+17) << "networkAddress = " << setprecision(indent) << m_networkAddress << '\n';
  8816.   if (HasOptionalField(e_alternativeNodeID))
  8817.     strm << setw(indent+20) << "alternativeNodeID = " << setprecision(indent) << m_alternativeNodeID << '\n';
  8818.   if (HasOptionalField(e_userData))
  8819.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  8820.   strm << setw(indent-1) << "}";
  8821. }
  8822. #endif
  8823.  
  8824.  
  8825. PObject::Comparison GCC_NodeRecord::Compare(const PObject & obj) const
  8826. {
  8827. #ifndef PASN_LEANANDMEAN
  8828.   PAssert(IsDescendant(GCC_NodeRecord::Class()), PInvalidCast);
  8829. #endif
  8830.   const GCC_NodeRecord & other = (const GCC_NodeRecord &)obj;
  8831.  
  8832.   Comparison result;
  8833.  
  8834.   if ((result = m_superiorNode.Compare(other.m_superiorNode)) != EqualTo)
  8835.     return result;
  8836.   if ((result = m_nodeType.Compare(other.m_nodeType)) != EqualTo)
  8837.     return result;
  8838.   if ((result = m_nodeProperties.Compare(other.m_nodeProperties)) != EqualTo)
  8839.     return result;
  8840.   if ((result = m_nodeName.Compare(other.m_nodeName)) != EqualTo)
  8841.     return result;
  8842.   if ((result = m_participantsList.Compare(other.m_participantsList)) != EqualTo)
  8843.     return result;
  8844.   if ((result = m_siteInformation.Compare(other.m_siteInformation)) != EqualTo)
  8845.     return result;
  8846.   if ((result = m_networkAddress.Compare(other.m_networkAddress)) != EqualTo)
  8847.     return result;
  8848.   if ((result = m_alternativeNodeID.Compare(other.m_alternativeNodeID)) != EqualTo)
  8849.     return result;
  8850.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  8851.     return result;
  8852.  
  8853.   return PASN_Sequence::Compare(other);
  8854. }
  8855.  
  8856.  
  8857. PINDEX GCC_NodeRecord::GetDataLength() const
  8858. {
  8859.   PINDEX length = 0;
  8860.   if (HasOptionalField(e_superiorNode))
  8861.     length += m_superiorNode.GetObjectLength();
  8862.   length += m_nodeType.GetObjectLength();
  8863.   length += m_nodeProperties.GetObjectLength();
  8864.   if (HasOptionalField(e_nodeName))
  8865.     length += m_nodeName.GetObjectLength();
  8866.   if (HasOptionalField(e_participantsList))
  8867.     length += m_participantsList.GetObjectLength();
  8868.   if (HasOptionalField(e_siteInformation))
  8869.     length += m_siteInformation.GetObjectLength();
  8870.   if (HasOptionalField(e_networkAddress))
  8871.     length += m_networkAddress.GetObjectLength();
  8872.   if (HasOptionalField(e_alternativeNodeID))
  8873.     length += m_alternativeNodeID.GetObjectLength();
  8874.   if (HasOptionalField(e_userData))
  8875.     length += m_userData.GetObjectLength();
  8876.   return length;
  8877. }
  8878.  
  8879.  
  8880. BOOL GCC_NodeRecord::Decode(PASN_Stream & strm)
  8881. {
  8882.   if (!PreambleDecode(strm))
  8883.     return FALSE;
  8884.  
  8885.   if (HasOptionalField(e_superiorNode) && !m_superiorNode.Decode(strm))
  8886.     return FALSE;
  8887.   if (!m_nodeType.Decode(strm))
  8888.     return FALSE;
  8889.   if (!m_nodeProperties.Decode(strm))
  8890.     return FALSE;
  8891.   if (HasOptionalField(e_nodeName) && !m_nodeName.Decode(strm))
  8892.     return FALSE;
  8893.   if (HasOptionalField(e_participantsList) && !m_participantsList.Decode(strm))
  8894.     return FALSE;
  8895.   if (HasOptionalField(e_siteInformation) && !m_siteInformation.Decode(strm))
  8896.     return FALSE;
  8897.   if (HasOptionalField(e_networkAddress) && !m_networkAddress.Decode(strm))
  8898.     return FALSE;
  8899.   if (HasOptionalField(e_alternativeNodeID) && !m_alternativeNodeID.Decode(strm))
  8900.     return FALSE;
  8901.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  8902.     return FALSE;
  8903.  
  8904.   return UnknownExtensionsDecode(strm);
  8905. }
  8906.  
  8907.  
  8908. void GCC_NodeRecord::Encode(PASN_Stream & strm) const
  8909. {
  8910.   PreambleEncode(strm);
  8911.  
  8912.   if (HasOptionalField(e_superiorNode))
  8913.     m_superiorNode.Encode(strm);
  8914.   m_nodeType.Encode(strm);
  8915.   m_nodeProperties.Encode(strm);
  8916.   if (HasOptionalField(e_nodeName))
  8917.     m_nodeName.Encode(strm);
  8918.   if (HasOptionalField(e_participantsList))
  8919.     m_participantsList.Encode(strm);
  8920.   if (HasOptionalField(e_siteInformation))
  8921.     m_siteInformation.Encode(strm);
  8922.   if (HasOptionalField(e_networkAddress))
  8923.     m_networkAddress.Encode(strm);
  8924.   if (HasOptionalField(e_alternativeNodeID))
  8925.     m_alternativeNodeID.Encode(strm);
  8926.   if (HasOptionalField(e_userData))
  8927.     m_userData.Encode(strm);
  8928.  
  8929.   UnknownExtensionsEncode(strm);
  8930. }
  8931.  
  8932.  
  8933. PObject * GCC_NodeRecord::Clone() const
  8934. {
  8935. #ifndef PASN_LEANANDMEAN
  8936.   PAssert(IsClass(GCC_NodeRecord::Class()), PInvalidCast);
  8937. #endif
  8938.   return new GCC_NodeRecord(*this);
  8939. }
  8940.  
  8941.  
  8942. //
  8943. // ApplicationRecord
  8944. //
  8945.  
  8946. GCC_ApplicationRecord::GCC_ApplicationRecord(unsigned tag, PASN_Object::TagClass tagClass)
  8947.   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
  8948. {
  8949. }
  8950.  
  8951.  
  8952. #ifndef PASN_NOPRINTON
  8953. void GCC_ApplicationRecord::PrintOn(ostream & strm) const
  8954. {
  8955.   int indent = strm.precision() + 2;
  8956.   strm << "{\n";
  8957.   strm << setw(indent+20) << "applicationActive = " << setprecision(indent) << m_applicationActive << '\n';
  8958.   strm << setw(indent+29) << "conductingOperationCapable = " << setprecision(indent) << m_conductingOperationCapable << '\n';
  8959.   if (HasOptionalField(e_startupChannel))
  8960.     strm << setw(indent+17) << "startupChannel = " << setprecision(indent) << m_startupChannel << '\n';
  8961.   if (HasOptionalField(e_applicationUserID))
  8962.     strm << setw(indent+20) << "applicationUserID = " << setprecision(indent) << m_applicationUserID << '\n';
  8963.   if (HasOptionalField(e_nonCollapsingCapabilities))
  8964.     strm << setw(indent+28) << "nonCollapsingCapabilities = " << setprecision(indent) << m_nonCollapsingCapabilities << '\n';
  8965.   strm << setw(indent-1) << "}";
  8966. }
  8967. #endif
  8968.  
  8969.  
  8970. PObject::Comparison GCC_ApplicationRecord::Compare(const PObject & obj) const
  8971. {
  8972. #ifndef PASN_LEANANDMEAN
  8973.   PAssert(IsDescendant(GCC_ApplicationRecord::Class()), PInvalidCast);
  8974. #endif
  8975.   const GCC_ApplicationRecord & other = (const GCC_ApplicationRecord &)obj;
  8976.  
  8977.   Comparison result;
  8978.  
  8979.   if ((result = m_applicationActive.Compare(other.m_applicationActive)) != EqualTo)
  8980.     return result;
  8981.   if ((result = m_conductingOperationCapable.Compare(other.m_conductingOperationCapable)) != EqualTo)
  8982.     return result;
  8983.   if ((result = m_startupChannel.Compare(other.m_startupChannel)) != EqualTo)
  8984.     return result;
  8985.   if ((result = m_applicationUserID.Compare(other.m_applicationUserID)) != EqualTo)
  8986.     return result;
  8987.   if ((result = m_nonCollapsingCapabilities.Compare(other.m_nonCollapsingCapabilities)) != EqualTo)
  8988.     return result;
  8989.  
  8990.   return PASN_Sequence::Compare(other);
  8991. }
  8992.  
  8993.  
  8994. PINDEX GCC_ApplicationRecord::GetDataLength() const
  8995. {
  8996.   PINDEX length = 0;
  8997.   length += m_applicationActive.GetObjectLength();
  8998.   length += m_conductingOperationCapable.GetObjectLength();
  8999.   if (HasOptionalField(e_startupChannel))
  9000.     length += m_startupChannel.GetObjectLength();
  9001.   if (HasOptionalField(e_applicationUserID))
  9002.     length += m_applicationUserID.GetObjectLength();
  9003.   if (HasOptionalField(e_nonCollapsingCapabilities))
  9004.     length += m_nonCollapsingCapabilities.GetObjectLength();
  9005.   return length;
  9006. }
  9007.  
  9008.  
  9009. BOOL GCC_ApplicationRecord::Decode(PASN_Stream & strm)
  9010. {
  9011.   if (!PreambleDecode(strm))
  9012.     return FALSE;
  9013.  
  9014.   if (!m_applicationActive.Decode(strm))
  9015.     return FALSE;
  9016.   if (!m_conductingOperationCapable.Decode(strm))
  9017.     return FALSE;
  9018.   if (HasOptionalField(e_startupChannel) && !m_startupChannel.Decode(strm))
  9019.     return FALSE;
  9020.   if (HasOptionalField(e_applicationUserID) && !m_applicationUserID.Decode(strm))
  9021.     return FALSE;
  9022.   if (HasOptionalField(e_nonCollapsingCapabilities) && !m_nonCollapsingCapabilities.Decode(strm))
  9023.     return FALSE;
  9024.  
  9025.   return UnknownExtensionsDecode(strm);
  9026. }
  9027.  
  9028.  
  9029. void GCC_ApplicationRecord::Encode(PASN_Stream & strm) const
  9030. {
  9031.   PreambleEncode(strm);
  9032.  
  9033.   m_applicationActive.Encode(strm);
  9034.   m_conductingOperationCapable.Encode(strm);
  9035.   if (HasOptionalField(e_startupChannel))
  9036.     m_startupChannel.Encode(strm);
  9037.   if (HasOptionalField(e_applicationUserID))
  9038.     m_applicationUserID.Encode(strm);
  9039.   if (HasOptionalField(e_nonCollapsingCapabilities))
  9040.     m_nonCollapsingCapabilities.Encode(strm);
  9041.  
  9042.   UnknownExtensionsEncode(strm);
  9043. }
  9044.  
  9045.  
  9046. PObject * GCC_ApplicationRecord::Clone() const
  9047. {
  9048. #ifndef PASN_LEANANDMEAN
  9049.   PAssert(IsClass(GCC_ApplicationRecord::Class()), PInvalidCast);
  9050. #endif
  9051.   return new GCC_ApplicationRecord(*this);
  9052. }
  9053.  
  9054.  
  9055. //
  9056. // ApplicationInvokeSpecifier
  9057. //
  9058.  
  9059. GCC_ApplicationInvokeSpecifier::GCC_ApplicationInvokeSpecifier(unsigned tag, PASN_Object::TagClass tagClass)
  9060.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  9061. {
  9062. }
  9063.  
  9064.  
  9065. #ifndef PASN_NOPRINTON
  9066. void GCC_ApplicationInvokeSpecifier::PrintOn(ostream & strm) const
  9067. {
  9068.   int indent = strm.precision() + 2;
  9069.   strm << "{\n";
  9070.   strm << setw(indent+13) << "sessionKey = " << setprecision(indent) << m_sessionKey << '\n';
  9071.   if (HasOptionalField(e_expectedCapabilitySet))
  9072.     strm << setw(indent+24) << "expectedCapabilitySet = " << setprecision(indent) << m_expectedCapabilitySet << '\n';
  9073.   if (HasOptionalField(e_startupChannel))
  9074.     strm << setw(indent+17) << "startupChannel = " << setprecision(indent) << m_startupChannel << '\n';
  9075.   strm << setw(indent+16) << "mandatoryFlag = " << setprecision(indent) << m_mandatoryFlag << '\n';
  9076.   strm << setw(indent-1) << "}";
  9077. }
  9078. #endif
  9079.  
  9080.  
  9081. PObject::Comparison GCC_ApplicationInvokeSpecifier::Compare(const PObject & obj) const
  9082. {
  9083. #ifndef PASN_LEANANDMEAN
  9084.   PAssert(IsDescendant(GCC_ApplicationInvokeSpecifier::Class()), PInvalidCast);
  9085. #endif
  9086.   const GCC_ApplicationInvokeSpecifier & other = (const GCC_ApplicationInvokeSpecifier &)obj;
  9087.  
  9088.   Comparison result;
  9089.  
  9090.   if ((result = m_sessionKey.Compare(other.m_sessionKey)) != EqualTo)
  9091.     return result;
  9092.   if ((result = m_expectedCapabilitySet.Compare(other.m_expectedCapabilitySet)) != EqualTo)
  9093.     return result;
  9094.   if ((result = m_startupChannel.Compare(other.m_startupChannel)) != EqualTo)
  9095.     return result;
  9096.   if ((result = m_mandatoryFlag.Compare(other.m_mandatoryFlag)) != EqualTo)
  9097.     return result;
  9098.  
  9099.   return PASN_Sequence::Compare(other);
  9100. }
  9101.  
  9102.  
  9103. PINDEX GCC_ApplicationInvokeSpecifier::GetDataLength() const
  9104. {
  9105.   PINDEX length = 0;
  9106.   length += m_sessionKey.GetObjectLength();
  9107.   if (HasOptionalField(e_expectedCapabilitySet))
  9108.     length += m_expectedCapabilitySet.GetObjectLength();
  9109.   if (HasOptionalField(e_startupChannel))
  9110.     length += m_startupChannel.GetObjectLength();
  9111.   length += m_mandatoryFlag.GetObjectLength();
  9112.   return length;
  9113. }
  9114.  
  9115.  
  9116. BOOL GCC_ApplicationInvokeSpecifier::Decode(PASN_Stream & strm)
  9117. {
  9118.   if (!PreambleDecode(strm))
  9119.     return FALSE;
  9120.  
  9121.   if (!m_sessionKey.Decode(strm))
  9122.     return FALSE;
  9123.   if (HasOptionalField(e_expectedCapabilitySet) && !m_expectedCapabilitySet.Decode(strm))
  9124.     return FALSE;
  9125.   if (HasOptionalField(e_startupChannel) && !m_startupChannel.Decode(strm))
  9126.     return FALSE;
  9127.   if (!m_mandatoryFlag.Decode(strm))
  9128.     return FALSE;
  9129.  
  9130.   return UnknownExtensionsDecode(strm);
  9131. }
  9132.  
  9133.  
  9134. void GCC_ApplicationInvokeSpecifier::Encode(PASN_Stream & strm) const
  9135. {
  9136.   PreambleEncode(strm);
  9137.  
  9138.   m_sessionKey.Encode(strm);
  9139.   if (HasOptionalField(e_expectedCapabilitySet))
  9140.     m_expectedCapabilitySet.Encode(strm);
  9141.   if (HasOptionalField(e_startupChannel))
  9142.     m_startupChannel.Encode(strm);
  9143.   m_mandatoryFlag.Encode(strm);
  9144.  
  9145.   UnknownExtensionsEncode(strm);
  9146. }
  9147.  
  9148.  
  9149. PObject * GCC_ApplicationInvokeSpecifier::Clone() const
  9150. {
  9151. #ifndef PASN_LEANANDMEAN
  9152.   PAssert(IsClass(GCC_ApplicationInvokeSpecifier::Class()), PInvalidCast);
  9153. #endif
  9154.   return new GCC_ApplicationInvokeSpecifier(*this);
  9155. }
  9156.  
  9157.  
  9158. //
  9159. // ConferenceCreateRequest
  9160. //
  9161.  
  9162. GCC_ConferenceCreateRequest::GCC_ConferenceCreateRequest(unsigned tag, PASN_Object::TagClass tagClass)
  9163.   : PASN_Sequence(tag, tagClass, 8, TRUE, 1)
  9164. {
  9165. }
  9166.  
  9167.  
  9168. #ifndef PASN_NOPRINTON
  9169. void GCC_ConferenceCreateRequest::PrintOn(ostream & strm) const
  9170. {
  9171.   int indent = strm.precision() + 2;
  9172.   strm << "{\n";
  9173.   strm << setw(indent+17) << "conferenceName = " << setprecision(indent) << m_conferenceName << '\n';
  9174.   if (HasOptionalField(e_convenerPassword))
  9175.     strm << setw(indent+19) << "convenerPassword = " << setprecision(indent) << m_convenerPassword << '\n';
  9176.   if (HasOptionalField(e_password))
  9177.     strm << setw(indent+11) << "password = " << setprecision(indent) << m_password << '\n';
  9178.   strm << setw(indent+19) << "lockedConference = " << setprecision(indent) << m_lockedConference << '\n';
  9179.   strm << setw(indent+19) << "listedConference = " << setprecision(indent) << m_listedConference << '\n';
  9180.   strm << setw(indent+24) << "conductibleConference = " << setprecision(indent) << m_conductibleConference << '\n';
  9181.   strm << setw(indent+20) << "terminationMethod = " << setprecision(indent) << m_terminationMethod << '\n';
  9182.   if (HasOptionalField(e_conductorPrivileges))
  9183.     strm << setw(indent+22) << "conductorPrivileges = " << setprecision(indent) << m_conductorPrivileges << '\n';
  9184.   if (HasOptionalField(e_conductedPrivileges))
  9185.     strm << setw(indent+22) << "conductedPrivileges = " << setprecision(indent) << m_conductedPrivileges << '\n';
  9186.   if (HasOptionalField(e_nonConductedPrivileges))
  9187.     strm << setw(indent+25) << "nonConductedPrivileges = " << setprecision(indent) << m_nonConductedPrivileges << '\n';
  9188.   if (HasOptionalField(e_conferenceDescription))
  9189.     strm << setw(indent+24) << "conferenceDescription = " << setprecision(indent) << m_conferenceDescription << '\n';
  9190.   if (HasOptionalField(e_callerIdentifier))
  9191.     strm << setw(indent+19) << "callerIdentifier = " << setprecision(indent) << m_callerIdentifier << '\n';
  9192.   if (HasOptionalField(e_userData))
  9193.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  9194.   if (HasOptionalField(e_conferencePriority))
  9195.     strm << setw(indent+21) << "conferencePriority = " << setprecision(indent) << m_conferencePriority << '\n';
  9196.   strm << setw(indent-1) << "}";
  9197. }
  9198. #endif
  9199.  
  9200.  
  9201. PObject::Comparison GCC_ConferenceCreateRequest::Compare(const PObject & obj) const
  9202. {
  9203. #ifndef PASN_LEANANDMEAN
  9204.   PAssert(IsDescendant(GCC_ConferenceCreateRequest::Class()), PInvalidCast);
  9205. #endif
  9206.   const GCC_ConferenceCreateRequest & other = (const GCC_ConferenceCreateRequest &)obj;
  9207.  
  9208.   Comparison result;
  9209.  
  9210.   if ((result = m_conferenceName.Compare(other.m_conferenceName)) != EqualTo)
  9211.     return result;
  9212.   if ((result = m_convenerPassword.Compare(other.m_convenerPassword)) != EqualTo)
  9213.     return result;
  9214.   if ((result = m_password.Compare(other.m_password)) != EqualTo)
  9215.     return result;
  9216.   if ((result = m_lockedConference.Compare(other.m_lockedConference)) != EqualTo)
  9217.     return result;
  9218.   if ((result = m_listedConference.Compare(other.m_listedConference)) != EqualTo)
  9219.     return result;
  9220.   if ((result = m_conductibleConference.Compare(other.m_conductibleConference)) != EqualTo)
  9221.     return result;
  9222.   if ((result = m_terminationMethod.Compare(other.m_terminationMethod)) != EqualTo)
  9223.     return result;
  9224.   if ((result = m_conductorPrivileges.Compare(other.m_conductorPrivileges)) != EqualTo)
  9225.     return result;
  9226.   if ((result = m_conductedPrivileges.Compare(other.m_conductedPrivileges)) != EqualTo)
  9227.     return result;
  9228.   if ((result = m_nonConductedPrivileges.Compare(other.m_nonConductedPrivileges)) != EqualTo)
  9229.     return result;
  9230.   if ((result = m_conferenceDescription.Compare(other.m_conferenceDescription)) != EqualTo)
  9231.     return result;
  9232.   if ((result = m_callerIdentifier.Compare(other.m_callerIdentifier)) != EqualTo)
  9233.     return result;
  9234.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  9235.     return result;
  9236.  
  9237.   return PASN_Sequence::Compare(other);
  9238. }
  9239.  
  9240.  
  9241. PINDEX GCC_ConferenceCreateRequest::GetDataLength() const
  9242. {
  9243.   PINDEX length = 0;
  9244.   length += m_conferenceName.GetObjectLength();
  9245.   if (HasOptionalField(e_convenerPassword))
  9246.     length += m_convenerPassword.GetObjectLength();
  9247.   if (HasOptionalField(e_password))
  9248.     length += m_password.GetObjectLength();
  9249.   length += m_lockedConference.GetObjectLength();
  9250.   length += m_listedConference.GetObjectLength();
  9251.   length += m_conductibleConference.GetObjectLength();
  9252.   length += m_terminationMethod.GetObjectLength();
  9253.   if (HasOptionalField(e_conductorPrivileges))
  9254.     length += m_conductorPrivileges.GetObjectLength();
  9255.   if (HasOptionalField(e_conductedPrivileges))
  9256.     length += m_conductedPrivileges.GetObjectLength();
  9257.   if (HasOptionalField(e_nonConductedPrivileges))
  9258.     length += m_nonConductedPrivileges.GetObjectLength();
  9259.   if (HasOptionalField(e_conferenceDescription))
  9260.     length += m_conferenceDescription.GetObjectLength();
  9261.   if (HasOptionalField(e_callerIdentifier))
  9262.     length += m_callerIdentifier.GetObjectLength();
  9263.   if (HasOptionalField(e_userData))
  9264.     length += m_userData.GetObjectLength();
  9265.   return length;
  9266. }
  9267.  
  9268.  
  9269. BOOL GCC_ConferenceCreateRequest::Decode(PASN_Stream & strm)
  9270. {
  9271.   if (!PreambleDecode(strm))
  9272.     return FALSE;
  9273.  
  9274.   if (!m_conferenceName.Decode(strm))
  9275.     return FALSE;
  9276.   if (HasOptionalField(e_convenerPassword) && !m_convenerPassword.Decode(strm))
  9277.     return FALSE;
  9278.   if (HasOptionalField(e_password) && !m_password.Decode(strm))
  9279.     return FALSE;
  9280.   if (!m_lockedConference.Decode(strm))
  9281.     return FALSE;
  9282.   if (!m_listedConference.Decode(strm))
  9283.     return FALSE;
  9284.   if (!m_conductibleConference.Decode(strm))
  9285.     return FALSE;
  9286.   if (!m_terminationMethod.Decode(strm))
  9287.     return FALSE;
  9288.   if (HasOptionalField(e_conductorPrivileges) && !m_conductorPrivileges.Decode(strm))
  9289.     return FALSE;
  9290.   if (HasOptionalField(e_conductedPrivileges) && !m_conductedPrivileges.Decode(strm))
  9291.     return FALSE;
  9292.   if (HasOptionalField(e_nonConductedPrivileges) && !m_nonConductedPrivileges.Decode(strm))
  9293.     return FALSE;
  9294.   if (HasOptionalField(e_conferenceDescription) && !m_conferenceDescription.Decode(strm))
  9295.     return FALSE;
  9296.   if (HasOptionalField(e_callerIdentifier) && !m_callerIdentifier.Decode(strm))
  9297.     return FALSE;
  9298.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  9299.     return FALSE;
  9300.   if (!KnownExtensionDecode(strm, e_conferencePriority, m_conferencePriority))
  9301.     return FALSE;
  9302.  
  9303.   return UnknownExtensionsDecode(strm);
  9304. }
  9305.  
  9306.  
  9307. void GCC_ConferenceCreateRequest::Encode(PASN_Stream & strm) const
  9308. {
  9309.   PreambleEncode(strm);
  9310.  
  9311.   m_conferenceName.Encode(strm);
  9312.   if (HasOptionalField(e_convenerPassword))
  9313.     m_convenerPassword.Encode(strm);
  9314.   if (HasOptionalField(e_password))
  9315.     m_password.Encode(strm);
  9316.   m_lockedConference.Encode(strm);
  9317.   m_listedConference.Encode(strm);
  9318.   m_conductibleConference.Encode(strm);
  9319.   m_terminationMethod.Encode(strm);
  9320.   if (HasOptionalField(e_conductorPrivileges))
  9321.     m_conductorPrivileges.Encode(strm);
  9322.   if (HasOptionalField(e_conductedPrivileges))
  9323.     m_conductedPrivileges.Encode(strm);
  9324.   if (HasOptionalField(e_nonConductedPrivileges))
  9325.     m_nonConductedPrivileges.Encode(strm);
  9326.   if (HasOptionalField(e_conferenceDescription))
  9327.     m_conferenceDescription.Encode(strm);
  9328.   if (HasOptionalField(e_callerIdentifier))
  9329.     m_callerIdentifier.Encode(strm);
  9330.   if (HasOptionalField(e_userData))
  9331.     m_userData.Encode(strm);
  9332.   KnownExtensionEncode(strm, e_conferencePriority, m_conferencePriority);
  9333.  
  9334.   UnknownExtensionsEncode(strm);
  9335. }
  9336.  
  9337.  
  9338. PObject * GCC_ConferenceCreateRequest::Clone() const
  9339. {
  9340. #ifndef PASN_LEANANDMEAN
  9341.   PAssert(IsClass(GCC_ConferenceCreateRequest::Class()), PInvalidCast);
  9342. #endif
  9343.   return new GCC_ConferenceCreateRequest(*this);
  9344. }
  9345.  
  9346.  
  9347. //
  9348. // ConferenceCreateResponse
  9349. //
  9350.  
  9351. GCC_ConferenceCreateResponse::GCC_ConferenceCreateResponse(unsigned tag, PASN_Object::TagClass tagClass)
  9352.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  9353. {
  9354. }
  9355.  
  9356.  
  9357. #ifndef PASN_NOPRINTON
  9358. void GCC_ConferenceCreateResponse::PrintOn(ostream & strm) const
  9359. {
  9360.   int indent = strm.precision() + 2;
  9361.   strm << "{\n";
  9362.   strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  9363.   strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  9364.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  9365.   if (HasOptionalField(e_userData))
  9366.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  9367.   strm << setw(indent-1) << "}";
  9368. }
  9369. #endif
  9370.  
  9371.  
  9372. PObject::Comparison GCC_ConferenceCreateResponse::Compare(const PObject & obj) const
  9373. {
  9374. #ifndef PASN_LEANANDMEAN
  9375.   PAssert(IsDescendant(GCC_ConferenceCreateResponse::Class()), PInvalidCast);
  9376. #endif
  9377.   const GCC_ConferenceCreateResponse & other = (const GCC_ConferenceCreateResponse &)obj;
  9378.  
  9379.   Comparison result;
  9380.  
  9381.   if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
  9382.     return result;
  9383.   if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
  9384.     return result;
  9385.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  9386.     return result;
  9387.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  9388.     return result;
  9389.  
  9390.   return PASN_Sequence::Compare(other);
  9391. }
  9392.  
  9393.  
  9394. PINDEX GCC_ConferenceCreateResponse::GetDataLength() const
  9395. {
  9396.   PINDEX length = 0;
  9397.   length += m_nodeID.GetObjectLength();
  9398.   length += m_tag.GetObjectLength();
  9399.   length += m_result.GetObjectLength();
  9400.   if (HasOptionalField(e_userData))
  9401.     length += m_userData.GetObjectLength();
  9402.   return length;
  9403. }
  9404.  
  9405.  
  9406. BOOL GCC_ConferenceCreateResponse::Decode(PASN_Stream & strm)
  9407. {
  9408.   if (!PreambleDecode(strm))
  9409.     return FALSE;
  9410.  
  9411.   if (!m_nodeID.Decode(strm))
  9412.     return FALSE;
  9413.   if (!m_tag.Decode(strm))
  9414.     return FALSE;
  9415.   if (!m_result.Decode(strm))
  9416.     return FALSE;
  9417.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  9418.     return FALSE;
  9419.  
  9420.   return UnknownExtensionsDecode(strm);
  9421. }
  9422.  
  9423.  
  9424. void GCC_ConferenceCreateResponse::Encode(PASN_Stream & strm) const
  9425. {
  9426.   PreambleEncode(strm);
  9427.  
  9428.   m_nodeID.Encode(strm);
  9429.   m_tag.Encode(strm);
  9430.   m_result.Encode(strm);
  9431.   if (HasOptionalField(e_userData))
  9432.     m_userData.Encode(strm);
  9433.  
  9434.   UnknownExtensionsEncode(strm);
  9435. }
  9436.  
  9437.  
  9438. PObject * GCC_ConferenceCreateResponse::Clone() const
  9439. {
  9440. #ifndef PASN_LEANANDMEAN
  9441.   PAssert(IsClass(GCC_ConferenceCreateResponse::Class()), PInvalidCast);
  9442. #endif
  9443.   return new GCC_ConferenceCreateResponse(*this);
  9444. }
  9445.  
  9446.  
  9447. //
  9448. // ConferenceQueryResponse
  9449. //
  9450.  
  9451. GCC_ConferenceQueryResponse::GCC_ConferenceQueryResponse(unsigned tag, PASN_Object::TagClass tagClass)
  9452.   : PASN_Sequence(tag, tagClass, 2, TRUE, 2)
  9453. {
  9454. }
  9455.  
  9456.  
  9457. #ifndef PASN_NOPRINTON
  9458. void GCC_ConferenceQueryResponse::PrintOn(ostream & strm) const
  9459. {
  9460.   int indent = strm.precision() + 2;
  9461.   strm << "{\n";
  9462.   strm << setw(indent+11) << "nodeType = " << setprecision(indent) << m_nodeType << '\n';
  9463.   if (HasOptionalField(e_asymmetryIndicator))
  9464.     strm << setw(indent+21) << "asymmetryIndicator = " << setprecision(indent) << m_asymmetryIndicator << '\n';
  9465.   strm << setw(indent+17) << "conferenceList = " << setprecision(indent) << m_conferenceList << '\n';
  9466.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  9467.   if (HasOptionalField(e_userData))
  9468.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  9469.   if (HasOptionalField(e_waitForInvitationFlag))
  9470.     strm << setw(indent+24) << "waitForInvitationFlag = " << setprecision(indent) << m_waitForInvitationFlag << '\n';
  9471.   if (HasOptionalField(e_noUnlistedConferenceFlag))
  9472.     strm << setw(indent+27) << "noUnlistedConferenceFlag = " << setprecision(indent) << m_noUnlistedConferenceFlag << '\n';
  9473.   strm << setw(indent-1) << "}";
  9474. }
  9475. #endif
  9476.  
  9477.  
  9478. PObject::Comparison GCC_ConferenceQueryResponse::Compare(const PObject & obj) const
  9479. {
  9480. #ifndef PASN_LEANANDMEAN
  9481.   PAssert(IsDescendant(GCC_ConferenceQueryResponse::Class()), PInvalidCast);
  9482. #endif
  9483.   const GCC_ConferenceQueryResponse & other = (const GCC_ConferenceQueryResponse &)obj;
  9484.  
  9485.   Comparison result;
  9486.  
  9487.   if ((result = m_nodeType.Compare(other.m_nodeType)) != EqualTo)
  9488.     return result;
  9489.   if ((result = m_asymmetryIndicator.Compare(other.m_asymmetryIndicator)) != EqualTo)
  9490.     return result;
  9491.   if ((result = m_conferenceList.Compare(other.m_conferenceList)) != EqualTo)
  9492.     return result;
  9493.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  9494.     return result;
  9495.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  9496.     return result;
  9497.  
  9498.   return PASN_Sequence::Compare(other);
  9499. }
  9500.  
  9501.  
  9502. PINDEX GCC_ConferenceQueryResponse::GetDataLength() const
  9503. {
  9504.   PINDEX length = 0;
  9505.   length += m_nodeType.GetObjectLength();
  9506.   if (HasOptionalField(e_asymmetryIndicator))
  9507.     length += m_asymmetryIndicator.GetObjectLength();
  9508.   length += m_conferenceList.GetObjectLength();
  9509.   length += m_result.GetObjectLength();
  9510.   if (HasOptionalField(e_userData))
  9511.     length += m_userData.GetObjectLength();
  9512.   return length;
  9513. }
  9514.  
  9515.  
  9516. BOOL GCC_ConferenceQueryResponse::Decode(PASN_Stream & strm)
  9517. {
  9518.   if (!PreambleDecode(strm))
  9519.     return FALSE;
  9520.  
  9521.   if (!m_nodeType.Decode(strm))
  9522.     return FALSE;
  9523.   if (HasOptionalField(e_asymmetryIndicator) && !m_asymmetryIndicator.Decode(strm))
  9524.     return FALSE;
  9525.   if (!m_conferenceList.Decode(strm))
  9526.     return FALSE;
  9527.   if (!m_result.Decode(strm))
  9528.     return FALSE;
  9529.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  9530.     return FALSE;
  9531.   if (!KnownExtensionDecode(strm, e_waitForInvitationFlag, m_waitForInvitationFlag))
  9532.     return FALSE;
  9533.   if (!KnownExtensionDecode(strm, e_noUnlistedConferenceFlag, m_noUnlistedConferenceFlag))
  9534.     return FALSE;
  9535.  
  9536.   return UnknownExtensionsDecode(strm);
  9537. }
  9538.  
  9539.  
  9540. void GCC_ConferenceQueryResponse::Encode(PASN_Stream & strm) const
  9541. {
  9542.   PreambleEncode(strm);
  9543.  
  9544.   m_nodeType.Encode(strm);
  9545.   if (HasOptionalField(e_asymmetryIndicator))
  9546.     m_asymmetryIndicator.Encode(strm);
  9547.   m_conferenceList.Encode(strm);
  9548.   m_result.Encode(strm);
  9549.   if (HasOptionalField(e_userData))
  9550.     m_userData.Encode(strm);
  9551.   KnownExtensionEncode(strm, e_waitForInvitationFlag, m_waitForInvitationFlag);
  9552.   KnownExtensionEncode(strm, e_noUnlistedConferenceFlag, m_noUnlistedConferenceFlag);
  9553.  
  9554.   UnknownExtensionsEncode(strm);
  9555. }
  9556.  
  9557.  
  9558. PObject * GCC_ConferenceQueryResponse::Clone() const
  9559. {
  9560. #ifndef PASN_LEANANDMEAN
  9561.   PAssert(IsClass(GCC_ConferenceQueryResponse::Class()), PInvalidCast);
  9562. #endif
  9563.   return new GCC_ConferenceQueryResponse(*this);
  9564. }
  9565.  
  9566.  
  9567. //
  9568. // ConferenceJoinResponse
  9569. //
  9570.  
  9571. GCC_ConferenceJoinResponse::GCC_ConferenceJoinResponse(unsigned tag, PASN_Object::TagClass tagClass)
  9572.   : PASN_Sequence(tag, tagClass, 8, TRUE, 0)
  9573. {
  9574. }
  9575.  
  9576.  
  9577. #ifndef PASN_NOPRINTON
  9578. void GCC_ConferenceJoinResponse::PrintOn(ostream & strm) const
  9579. {
  9580.   int indent = strm.precision() + 2;
  9581.   strm << "{\n";
  9582.   if (HasOptionalField(e_nodeID))
  9583.     strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  9584.   strm << setw(indent+12) << "topNodeID = " << setprecision(indent) << m_topNodeID << '\n';
  9585.   strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  9586.   if (HasOptionalField(e_conferenceNameAlias))
  9587.     strm << setw(indent+22) << "conferenceNameAlias = " << setprecision(indent) << m_conferenceNameAlias << '\n';
  9588.   strm << setw(indent+29) << "passwordInTheClearRequired = " << setprecision(indent) << m_passwordInTheClearRequired << '\n';
  9589.   strm << setw(indent+19) << "lockedConference = " << setprecision(indent) << m_lockedConference << '\n';
  9590.   strm << setw(indent+19) << "listedConference = " << setprecision(indent) << m_listedConference << '\n';
  9591.   strm << setw(indent+24) << "conductibleConference = " << setprecision(indent) << m_conductibleConference << '\n';
  9592.   strm << setw(indent+20) << "terminationMethod = " << setprecision(indent) << m_terminationMethod << '\n';
  9593.   if (HasOptionalField(e_conductorPrivileges))
  9594.     strm << setw(indent+22) << "conductorPrivileges = " << setprecision(indent) << m_conductorPrivileges << '\n';
  9595.   if (HasOptionalField(e_conductedPrivileges))
  9596.     strm << setw(indent+22) << "conductedPrivileges = " << setprecision(indent) << m_conductedPrivileges << '\n';
  9597.   if (HasOptionalField(e_nonConductedPrivileges))
  9598.     strm << setw(indent+25) << "nonConductedPrivileges = " << setprecision(indent) << m_nonConductedPrivileges << '\n';
  9599.   if (HasOptionalField(e_conferenceDescription))
  9600.     strm << setw(indent+24) << "conferenceDescription = " << setprecision(indent) << m_conferenceDescription << '\n';
  9601.   if (HasOptionalField(e_password))
  9602.     strm << setw(indent+11) << "password = " << setprecision(indent) << m_password << '\n';
  9603.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  9604.   if (HasOptionalField(e_userData))
  9605.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  9606.   strm << setw(indent-1) << "}";
  9607. }
  9608. #endif
  9609.  
  9610.  
  9611. PObject::Comparison GCC_ConferenceJoinResponse::Compare(const PObject & obj) const
  9612. {
  9613. #ifndef PASN_LEANANDMEAN
  9614.   PAssert(IsDescendant(GCC_ConferenceJoinResponse::Class()), PInvalidCast);
  9615. #endif
  9616.   const GCC_ConferenceJoinResponse & other = (const GCC_ConferenceJoinResponse &)obj;
  9617.  
  9618.   Comparison result;
  9619.  
  9620.   if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
  9621.     return result;
  9622.   if ((result = m_topNodeID.Compare(other.m_topNodeID)) != EqualTo)
  9623.     return result;
  9624.   if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
  9625.     return result;
  9626.   if ((result = m_conferenceNameAlias.Compare(other.m_conferenceNameAlias)) != EqualTo)
  9627.     return result;
  9628.   if ((result = m_passwordInTheClearRequired.Compare(other.m_passwordInTheClearRequired)) != EqualTo)
  9629.     return result;
  9630.   if ((result = m_lockedConference.Compare(other.m_lockedConference)) != EqualTo)
  9631.     return result;
  9632.   if ((result = m_listedConference.Compare(other.m_listedConference)) != EqualTo)
  9633.     return result;
  9634.   if ((result = m_conductibleConference.Compare(other.m_conductibleConference)) != EqualTo)
  9635.     return result;
  9636.   if ((result = m_terminationMethod.Compare(other.m_terminationMethod)) != EqualTo)
  9637.     return result;
  9638.   if ((result = m_conductorPrivileges.Compare(other.m_conductorPrivileges)) != EqualTo)
  9639.     return result;
  9640.   if ((result = m_conductedPrivileges.Compare(other.m_conductedPrivileges)) != EqualTo)
  9641.     return result;
  9642.   if ((result = m_nonConductedPrivileges.Compare(other.m_nonConductedPrivileges)) != EqualTo)
  9643.     return result;
  9644.   if ((result = m_conferenceDescription.Compare(other.m_conferenceDescription)) != EqualTo)
  9645.     return result;
  9646.   if ((result = m_password.Compare(other.m_password)) != EqualTo)
  9647.     return result;
  9648.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  9649.     return result;
  9650.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  9651.     return result;
  9652.  
  9653.   return PASN_Sequence::Compare(other);
  9654. }
  9655.  
  9656.  
  9657. PINDEX GCC_ConferenceJoinResponse::GetDataLength() const
  9658. {
  9659.   PINDEX length = 0;
  9660.   if (HasOptionalField(e_nodeID))
  9661.     length += m_nodeID.GetObjectLength();
  9662.   length += m_topNodeID.GetObjectLength();
  9663.   length += m_tag.GetObjectLength();
  9664.   if (HasOptionalField(e_conferenceNameAlias))
  9665.     length += m_conferenceNameAlias.GetObjectLength();
  9666.   length += m_passwordInTheClearRequired.GetObjectLength();
  9667.   length += m_lockedConference.GetObjectLength();
  9668.   length += m_listedConference.GetObjectLength();
  9669.   length += m_conductibleConference.GetObjectLength();
  9670.   length += m_terminationMethod.GetObjectLength();
  9671.   if (HasOptionalField(e_conductorPrivileges))
  9672.     length += m_conductorPrivileges.GetObjectLength();
  9673.   if (HasOptionalField(e_conductedPrivileges))
  9674.     length += m_conductedPrivileges.GetObjectLength();
  9675.   if (HasOptionalField(e_nonConductedPrivileges))
  9676.     length += m_nonConductedPrivileges.GetObjectLength();
  9677.   if (HasOptionalField(e_conferenceDescription))
  9678.     length += m_conferenceDescription.GetObjectLength();
  9679.   if (HasOptionalField(e_password))
  9680.     length += m_password.GetObjectLength();
  9681.   length += m_result.GetObjectLength();
  9682.   if (HasOptionalField(e_userData))
  9683.     length += m_userData.GetObjectLength();
  9684.   return length;
  9685. }
  9686.  
  9687.  
  9688. BOOL GCC_ConferenceJoinResponse::Decode(PASN_Stream & strm)
  9689. {
  9690.   if (!PreambleDecode(strm))
  9691.     return FALSE;
  9692.  
  9693.   if (HasOptionalField(e_nodeID) && !m_nodeID.Decode(strm))
  9694.     return FALSE;
  9695.   if (!m_topNodeID.Decode(strm))
  9696.     return FALSE;
  9697.   if (!m_tag.Decode(strm))
  9698.     return FALSE;
  9699.   if (HasOptionalField(e_conferenceNameAlias) && !m_conferenceNameAlias.Decode(strm))
  9700.     return FALSE;
  9701.   if (!m_passwordInTheClearRequired.Decode(strm))
  9702.     return FALSE;
  9703.   if (!m_lockedConference.Decode(strm))
  9704.     return FALSE;
  9705.   if (!m_listedConference.Decode(strm))
  9706.     return FALSE;
  9707.   if (!m_conductibleConference.Decode(strm))
  9708.     return FALSE;
  9709.   if (!m_terminationMethod.Decode(strm))
  9710.     return FALSE;
  9711.   if (HasOptionalField(e_conductorPrivileges) && !m_conductorPrivileges.Decode(strm))
  9712.     return FALSE;
  9713.   if (HasOptionalField(e_conductedPrivileges) && !m_conductedPrivileges.Decode(strm))
  9714.     return FALSE;
  9715.   if (HasOptionalField(e_nonConductedPrivileges) && !m_nonConductedPrivileges.Decode(strm))
  9716.     return FALSE;
  9717.   if (HasOptionalField(e_conferenceDescription) && !m_conferenceDescription.Decode(strm))
  9718.     return FALSE;
  9719.   if (HasOptionalField(e_password) && !m_password.Decode(strm))
  9720.     return FALSE;
  9721.   if (!m_result.Decode(strm))
  9722.     return FALSE;
  9723.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  9724.     return FALSE;
  9725.  
  9726.   return UnknownExtensionsDecode(strm);
  9727. }
  9728.  
  9729.  
  9730. void GCC_ConferenceJoinResponse::Encode(PASN_Stream & strm) const
  9731. {
  9732.   PreambleEncode(strm);
  9733.  
  9734.   if (HasOptionalField(e_nodeID))
  9735.     m_nodeID.Encode(strm);
  9736.   m_topNodeID.Encode(strm);
  9737.   m_tag.Encode(strm);
  9738.   if (HasOptionalField(e_conferenceNameAlias))
  9739.     m_conferenceNameAlias.Encode(strm);
  9740.   m_passwordInTheClearRequired.Encode(strm);
  9741.   m_lockedConference.Encode(strm);
  9742.   m_listedConference.Encode(strm);
  9743.   m_conductibleConference.Encode(strm);
  9744.   m_terminationMethod.Encode(strm);
  9745.   if (HasOptionalField(e_conductorPrivileges))
  9746.     m_conductorPrivileges.Encode(strm);
  9747.   if (HasOptionalField(e_conductedPrivileges))
  9748.     m_conductedPrivileges.Encode(strm);
  9749.   if (HasOptionalField(e_nonConductedPrivileges))
  9750.     m_nonConductedPrivileges.Encode(strm);
  9751.   if (HasOptionalField(e_conferenceDescription))
  9752.     m_conferenceDescription.Encode(strm);
  9753.   if (HasOptionalField(e_password))
  9754.     m_password.Encode(strm);
  9755.   m_result.Encode(strm);
  9756.   if (HasOptionalField(e_userData))
  9757.     m_userData.Encode(strm);
  9758.  
  9759.   UnknownExtensionsEncode(strm);
  9760. }
  9761.  
  9762.  
  9763. PObject * GCC_ConferenceJoinResponse::Clone() const
  9764. {
  9765. #ifndef PASN_LEANANDMEAN
  9766.   PAssert(IsClass(GCC_ConferenceJoinResponse::Class()), PInvalidCast);
  9767. #endif
  9768.   return new GCC_ConferenceJoinResponse(*this);
  9769. }
  9770.  
  9771.  
  9772. //
  9773. // ConferenceInviteRequest
  9774. //
  9775.  
  9776. GCC_ConferenceInviteRequest::GCC_ConferenceInviteRequest(unsigned tag, PASN_Object::TagClass tagClass)
  9777.   : PASN_Sequence(tag, tagClass, 6, TRUE, 1)
  9778. {
  9779. }
  9780.  
  9781.  
  9782. #ifndef PASN_NOPRINTON
  9783. void GCC_ConferenceInviteRequest::PrintOn(ostream & strm) const
  9784. {
  9785.   int indent = strm.precision() + 2;
  9786.   strm << "{\n";
  9787.   strm << setw(indent+17) << "conferenceName = " << setprecision(indent) << m_conferenceName << '\n';
  9788.   strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  9789.   strm << setw(indent+12) << "topNodeID = " << setprecision(indent) << m_topNodeID << '\n';
  9790.   strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  9791.   strm << setw(indent+29) << "passwordInTheClearRequired = " << setprecision(indent) << m_passwordInTheClearRequired << '\n';
  9792.   strm << setw(indent+19) << "lockedConference = " << setprecision(indent) << m_lockedConference << '\n';
  9793.   strm << setw(indent+19) << "listedConference = " << setprecision(indent) << m_listedConference << '\n';
  9794.   strm << setw(indent+24) << "conductibleConference = " << setprecision(indent) << m_conductibleConference << '\n';
  9795.   strm << setw(indent+20) << "terminationMethod = " << setprecision(indent) << m_terminationMethod << '\n';
  9796.   if (HasOptionalField(e_conductorPrivileges))
  9797.     strm << setw(indent+22) << "conductorPrivileges = " << setprecision(indent) << m_conductorPrivileges << '\n';
  9798.   if (HasOptionalField(e_conductedPrivileges))
  9799.     strm << setw(indent+22) << "conductedPrivileges = " << setprecision(indent) << m_conductedPrivileges << '\n';
  9800.   if (HasOptionalField(e_nonConductedPrivileges))
  9801.     strm << setw(indent+25) << "nonConductedPrivileges = " << setprecision(indent) << m_nonConductedPrivileges << '\n';
  9802.   if (HasOptionalField(e_conferenceDescription))
  9803.     strm << setw(indent+24) << "conferenceDescription = " << setprecision(indent) << m_conferenceDescription << '\n';
  9804.   if (HasOptionalField(e_callerIdentifier))
  9805.     strm << setw(indent+19) << "callerIdentifier = " << setprecision(indent) << m_callerIdentifier << '\n';
  9806.   if (HasOptionalField(e_userData))
  9807.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  9808.   if (HasOptionalField(e_conferencePriority))
  9809.     strm << setw(indent+21) << "conferencePriority = " << setprecision(indent) << m_conferencePriority << '\n';
  9810.   strm << setw(indent-1) << "}";
  9811. }
  9812. #endif
  9813.  
  9814.  
  9815. PObject::Comparison GCC_ConferenceInviteRequest::Compare(const PObject & obj) const
  9816. {
  9817. #ifndef PASN_LEANANDMEAN
  9818.   PAssert(IsDescendant(GCC_ConferenceInviteRequest::Class()), PInvalidCast);
  9819. #endif
  9820.   const GCC_ConferenceInviteRequest & other = (const GCC_ConferenceInviteRequest &)obj;
  9821.  
  9822.   Comparison result;
  9823.  
  9824.   if ((result = m_conferenceName.Compare(other.m_conferenceName)) != EqualTo)
  9825.     return result;
  9826.   if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
  9827.     return result;
  9828.   if ((result = m_topNodeID.Compare(other.m_topNodeID)) != EqualTo)
  9829.     return result;
  9830.   if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
  9831.     return result;
  9832.   if ((result = m_passwordInTheClearRequired.Compare(other.m_passwordInTheClearRequired)) != EqualTo)
  9833.     return result;
  9834.   if ((result = m_lockedConference.Compare(other.m_lockedConference)) != EqualTo)
  9835.     return result;
  9836.   if ((result = m_listedConference.Compare(other.m_listedConference)) != EqualTo)
  9837.     return result;
  9838.   if ((result = m_conductibleConference.Compare(other.m_conductibleConference)) != EqualTo)
  9839.     return result;
  9840.   if ((result = m_terminationMethod.Compare(other.m_terminationMethod)) != EqualTo)
  9841.     return result;
  9842.   if ((result = m_conductorPrivileges.Compare(other.m_conductorPrivileges)) != EqualTo)
  9843.     return result;
  9844.   if ((result = m_conductedPrivileges.Compare(other.m_conductedPrivileges)) != EqualTo)
  9845.     return result;
  9846.   if ((result = m_nonConductedPrivileges.Compare(other.m_nonConductedPrivileges)) != EqualTo)
  9847.     return result;
  9848.   if ((result = m_conferenceDescription.Compare(other.m_conferenceDescription)) != EqualTo)
  9849.     return result;
  9850.   if ((result = m_callerIdentifier.Compare(other.m_callerIdentifier)) != EqualTo)
  9851.     return result;
  9852.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  9853.     return result;
  9854.  
  9855.   return PASN_Sequence::Compare(other);
  9856. }
  9857.  
  9858.  
  9859. PINDEX GCC_ConferenceInviteRequest::GetDataLength() const
  9860. {
  9861.   PINDEX length = 0;
  9862.   length += m_conferenceName.GetObjectLength();
  9863.   length += m_nodeID.GetObjectLength();
  9864.   length += m_topNodeID.GetObjectLength();
  9865.   length += m_tag.GetObjectLength();
  9866.   length += m_passwordInTheClearRequired.GetObjectLength();
  9867.   length += m_lockedConference.GetObjectLength();
  9868.   length += m_listedConference.GetObjectLength();
  9869.   length += m_conductibleConference.GetObjectLength();
  9870.   length += m_terminationMethod.GetObjectLength();
  9871.   if (HasOptionalField(e_conductorPrivileges))
  9872.     length += m_conductorPrivileges.GetObjectLength();
  9873.   if (HasOptionalField(e_conductedPrivileges))
  9874.     length += m_conductedPrivileges.GetObjectLength();
  9875.   if (HasOptionalField(e_nonConductedPrivileges))
  9876.     length += m_nonConductedPrivileges.GetObjectLength();
  9877.   if (HasOptionalField(e_conferenceDescription))
  9878.     length += m_conferenceDescription.GetObjectLength();
  9879.   if (HasOptionalField(e_callerIdentifier))
  9880.     length += m_callerIdentifier.GetObjectLength();
  9881.   if (HasOptionalField(e_userData))
  9882.     length += m_userData.GetObjectLength();
  9883.   return length;
  9884. }
  9885.  
  9886.  
  9887. BOOL GCC_ConferenceInviteRequest::Decode(PASN_Stream & strm)
  9888. {
  9889.   if (!PreambleDecode(strm))
  9890.     return FALSE;
  9891.  
  9892.   if (!m_conferenceName.Decode(strm))
  9893.     return FALSE;
  9894.   if (!m_nodeID.Decode(strm))
  9895.     return FALSE;
  9896.   if (!m_topNodeID.Decode(strm))
  9897.     return FALSE;
  9898.   if (!m_tag.Decode(strm))
  9899.     return FALSE;
  9900.   if (!m_passwordInTheClearRequired.Decode(strm))
  9901.     return FALSE;
  9902.   if (!m_lockedConference.Decode(strm))
  9903.     return FALSE;
  9904.   if (!m_listedConference.Decode(strm))
  9905.     return FALSE;
  9906.   if (!m_conductibleConference.Decode(strm))
  9907.     return FALSE;
  9908.   if (!m_terminationMethod.Decode(strm))
  9909.     return FALSE;
  9910.   if (HasOptionalField(e_conductorPrivileges) && !m_conductorPrivileges.Decode(strm))
  9911.     return FALSE;
  9912.   if (HasOptionalField(e_conductedPrivileges) && !m_conductedPrivileges.Decode(strm))
  9913.     return FALSE;
  9914.   if (HasOptionalField(e_nonConductedPrivileges) && !m_nonConductedPrivileges.Decode(strm))
  9915.     return FALSE;
  9916.   if (HasOptionalField(e_conferenceDescription) && !m_conferenceDescription.Decode(strm))
  9917.     return FALSE;
  9918.   if (HasOptionalField(e_callerIdentifier) && !m_callerIdentifier.Decode(strm))
  9919.     return FALSE;
  9920.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  9921.     return FALSE;
  9922.   if (!KnownExtensionDecode(strm, e_conferencePriority, m_conferencePriority))
  9923.     return FALSE;
  9924.  
  9925.   return UnknownExtensionsDecode(strm);
  9926. }
  9927.  
  9928.  
  9929. void GCC_ConferenceInviteRequest::Encode(PASN_Stream & strm) const
  9930. {
  9931.   PreambleEncode(strm);
  9932.  
  9933.   m_conferenceName.Encode(strm);
  9934.   m_nodeID.Encode(strm);
  9935.   m_topNodeID.Encode(strm);
  9936.   m_tag.Encode(strm);
  9937.   m_passwordInTheClearRequired.Encode(strm);
  9938.   m_lockedConference.Encode(strm);
  9939.   m_listedConference.Encode(strm);
  9940.   m_conductibleConference.Encode(strm);
  9941.   m_terminationMethod.Encode(strm);
  9942.   if (HasOptionalField(e_conductorPrivileges))
  9943.     m_conductorPrivileges.Encode(strm);
  9944.   if (HasOptionalField(e_conductedPrivileges))
  9945.     m_conductedPrivileges.Encode(strm);
  9946.   if (HasOptionalField(e_nonConductedPrivileges))
  9947.     m_nonConductedPrivileges.Encode(strm);
  9948.   if (HasOptionalField(e_conferenceDescription))
  9949.     m_conferenceDescription.Encode(strm);
  9950.   if (HasOptionalField(e_callerIdentifier))
  9951.     m_callerIdentifier.Encode(strm);
  9952.   if (HasOptionalField(e_userData))
  9953.     m_userData.Encode(strm);
  9954.   KnownExtensionEncode(strm, e_conferencePriority, m_conferencePriority);
  9955.  
  9956.   UnknownExtensionsEncode(strm);
  9957. }
  9958.  
  9959.  
  9960. PObject * GCC_ConferenceInviteRequest::Clone() const
  9961. {
  9962. #ifndef PASN_LEANANDMEAN
  9963.   PAssert(IsClass(GCC_ConferenceInviteRequest::Class()), PInvalidCast);
  9964. #endif
  9965.   return new GCC_ConferenceInviteRequest(*this);
  9966. }
  9967.  
  9968.  
  9969. //
  9970. // ConferenceInviteResponse
  9971. //
  9972.  
  9973. GCC_ConferenceInviteResponse::GCC_ConferenceInviteResponse(unsigned tag, PASN_Object::TagClass tagClass)
  9974.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  9975. {
  9976. }
  9977.  
  9978.  
  9979. #ifndef PASN_NOPRINTON
  9980. void GCC_ConferenceInviteResponse::PrintOn(ostream & strm) const
  9981. {
  9982.   int indent = strm.precision() + 2;
  9983.   strm << "{\n";
  9984.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  9985.   if (HasOptionalField(e_userData))
  9986.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  9987.   strm << setw(indent-1) << "}";
  9988. }
  9989. #endif
  9990.  
  9991.  
  9992. PObject::Comparison GCC_ConferenceInviteResponse::Compare(const PObject & obj) const
  9993. {
  9994. #ifndef PASN_LEANANDMEAN
  9995.   PAssert(IsDescendant(GCC_ConferenceInviteResponse::Class()), PInvalidCast);
  9996. #endif
  9997.   const GCC_ConferenceInviteResponse & other = (const GCC_ConferenceInviteResponse &)obj;
  9998.  
  9999.   Comparison result;
  10000.  
  10001.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  10002.     return result;
  10003.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  10004.     return result;
  10005.  
  10006.   return PASN_Sequence::Compare(other);
  10007. }
  10008.  
  10009.  
  10010. PINDEX GCC_ConferenceInviteResponse::GetDataLength() const
  10011. {
  10012.   PINDEX length = 0;
  10013.   length += m_result.GetObjectLength();
  10014.   if (HasOptionalField(e_userData))
  10015.     length += m_userData.GetObjectLength();
  10016.   return length;
  10017. }
  10018.  
  10019.  
  10020. BOOL GCC_ConferenceInviteResponse::Decode(PASN_Stream & strm)
  10021. {
  10022.   if (!PreambleDecode(strm))
  10023.     return FALSE;
  10024.  
  10025.   if (!m_result.Decode(strm))
  10026.     return FALSE;
  10027.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  10028.     return FALSE;
  10029.  
  10030.   return UnknownExtensionsDecode(strm);
  10031. }
  10032.  
  10033.  
  10034. void GCC_ConferenceInviteResponse::Encode(PASN_Stream & strm) const
  10035. {
  10036.   PreambleEncode(strm);
  10037.  
  10038.   m_result.Encode(strm);
  10039.   if (HasOptionalField(e_userData))
  10040.     m_userData.Encode(strm);
  10041.  
  10042.   UnknownExtensionsEncode(strm);
  10043. }
  10044.  
  10045.  
  10046. PObject * GCC_ConferenceInviteResponse::Clone() const
  10047. {
  10048. #ifndef PASN_LEANANDMEAN
  10049.   PAssert(IsClass(GCC_ConferenceInviteResponse::Class()), PInvalidCast);
  10050. #endif
  10051.   return new GCC_ConferenceInviteResponse(*this);
  10052. }
  10053.  
  10054.  
  10055. //
  10056. // ConferenceAddResponse
  10057. //
  10058.  
  10059. GCC_ConferenceAddResponse::GCC_ConferenceAddResponse(unsigned tag, PASN_Object::TagClass tagClass)
  10060.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  10061. {
  10062. }
  10063.  
  10064.  
  10065. #ifndef PASN_NOPRINTON
  10066. void GCC_ConferenceAddResponse::PrintOn(ostream & strm) const
  10067. {
  10068.   int indent = strm.precision() + 2;
  10069.   strm << "{\n";
  10070.   strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  10071.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  10072.   if (HasOptionalField(e_userData))
  10073.     strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  10074.   strm << setw(indent-1) << "}";
  10075. }
  10076. #endif
  10077.  
  10078.  
  10079. PObject::Comparison GCC_ConferenceAddResponse::Compare(const PObject & obj) const
  10080. {
  10081. #ifndef PASN_LEANANDMEAN
  10082.   PAssert(IsDescendant(GCC_ConferenceAddResponse::Class()), PInvalidCast);
  10083. #endif
  10084.   const GCC_ConferenceAddResponse & other = (const GCC_ConferenceAddResponse &)obj;
  10085.  
  10086.   Comparison result;
  10087.  
  10088.   if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
  10089.     return result;
  10090.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  10091.     return result;
  10092.   if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
  10093.     return result;
  10094.  
  10095.   return PASN_Sequence::Compare(other);
  10096. }
  10097.  
  10098.  
  10099. PINDEX GCC_ConferenceAddResponse::GetDataLength() const
  10100. {
  10101.   PINDEX length = 0;
  10102.   length += m_tag.GetObjectLength();
  10103.   length += m_result.GetObjectLength();
  10104.   if (HasOptionalField(e_userData))
  10105.     length += m_userData.GetObjectLength();
  10106.   return length;
  10107. }
  10108.  
  10109.  
  10110. BOOL GCC_ConferenceAddResponse::Decode(PASN_Stream & strm)
  10111. {
  10112.   if (!PreambleDecode(strm))
  10113.     return FALSE;
  10114.  
  10115.   if (!m_tag.Decode(strm))
  10116.     return FALSE;
  10117.   if (!m_result.Decode(strm))
  10118.     return FALSE;
  10119.   if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
  10120.     return FALSE;
  10121.  
  10122.   return UnknownExtensionsDecode(strm);
  10123. }
  10124.  
  10125.  
  10126. void GCC_ConferenceAddResponse::Encode(PASN_Stream & strm) const
  10127. {
  10128.   PreambleEncode(strm);
  10129.  
  10130.   m_tag.Encode(strm);
  10131.   m_result.Encode(strm);
  10132.   if (HasOptionalField(e_userData))
  10133.     m_userData.Encode(strm);
  10134.  
  10135.   UnknownExtensionsEncode(strm);
  10136. }
  10137.  
  10138.  
  10139. PObject * GCC_ConferenceAddResponse::Clone() const
  10140. {
  10141. #ifndef PASN_LEANANDMEAN
  10142.   PAssert(IsClass(GCC_ConferenceAddResponse::Class()), PInvalidCast);
  10143. #endif
  10144.   return new GCC_ConferenceAddResponse(*this);
  10145. }
  10146.  
  10147.  
  10148. //
  10149. // ConferenceLockResponse
  10150. //
  10151.  
  10152. GCC_ConferenceLockResponse::GCC_ConferenceLockResponse(unsigned tag, PASN_Object::TagClass tagClass)
  10153.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  10154. {
  10155. }
  10156.  
  10157.  
  10158. #ifndef PASN_NOPRINTON
  10159. void GCC_ConferenceLockResponse::PrintOn(ostream & strm) const
  10160. {
  10161.   int indent = strm.precision() + 2;
  10162.   strm << "{\n";
  10163.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  10164.   strm << setw(indent-1) << "}";
  10165. }
  10166. #endif
  10167.  
  10168.  
  10169. PObject::Comparison GCC_ConferenceLockResponse::Compare(const PObject & obj) const
  10170. {
  10171. #ifndef PASN_LEANANDMEAN
  10172.   PAssert(IsDescendant(GCC_ConferenceLockResponse::Class()), PInvalidCast);
  10173. #endif
  10174.   const GCC_ConferenceLockResponse & other = (const GCC_ConferenceLockResponse &)obj;
  10175.  
  10176.   Comparison result;
  10177.  
  10178.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  10179.     return result;
  10180.  
  10181.   return PASN_Sequence::Compare(other);
  10182. }
  10183.  
  10184.  
  10185. PINDEX GCC_ConferenceLockResponse::GetDataLength() const
  10186. {
  10187.   PINDEX length = 0;
  10188.   length += m_result.GetObjectLength();
  10189.   return length;
  10190. }
  10191.  
  10192.  
  10193. BOOL GCC_ConferenceLockResponse::Decode(PASN_Stream & strm)
  10194. {
  10195.   if (!PreambleDecode(strm))
  10196.     return FALSE;
  10197.  
  10198.   if (!m_result.Decode(strm))
  10199.     return FALSE;
  10200.  
  10201.   return UnknownExtensionsDecode(strm);
  10202. }
  10203.  
  10204.  
  10205. void GCC_ConferenceLockResponse::Encode(PASN_Stream & strm) const
  10206. {
  10207.   PreambleEncode(strm);
  10208.  
  10209.   m_result.Encode(strm);
  10210.  
  10211.   UnknownExtensionsEncode(strm);
  10212. }
  10213.  
  10214.  
  10215. PObject * GCC_ConferenceLockResponse::Clone() const
  10216. {
  10217. #ifndef PASN_LEANANDMEAN
  10218.   PAssert(IsClass(GCC_ConferenceLockResponse::Class()), PInvalidCast);
  10219. #endif
  10220.   return new GCC_ConferenceLockResponse(*this);
  10221. }
  10222.  
  10223.  
  10224. //
  10225. // ConferenceUnlockResponse
  10226. //
  10227.  
  10228. GCC_ConferenceUnlockResponse::GCC_ConferenceUnlockResponse(unsigned tag, PASN_Object::TagClass tagClass)
  10229.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  10230. {
  10231. }
  10232.  
  10233.  
  10234. #ifndef PASN_NOPRINTON
  10235. void GCC_ConferenceUnlockResponse::PrintOn(ostream & strm) const
  10236. {
  10237.   int indent = strm.precision() + 2;
  10238.   strm << "{\n";
  10239.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  10240.   strm << setw(indent-1) << "}";
  10241. }
  10242. #endif
  10243.  
  10244.  
  10245. PObject::Comparison GCC_ConferenceUnlockResponse::Compare(const PObject & obj) const
  10246. {
  10247. #ifndef PASN_LEANANDMEAN
  10248.   PAssert(IsDescendant(GCC_ConferenceUnlockResponse::Class()), PInvalidCast);
  10249. #endif
  10250.   const GCC_ConferenceUnlockResponse & other = (const GCC_ConferenceUnlockResponse &)obj;
  10251.  
  10252.   Comparison result;
  10253.  
  10254.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  10255.     return result;
  10256.  
  10257.   return PASN_Sequence::Compare(other);
  10258. }
  10259.  
  10260.  
  10261. PINDEX GCC_ConferenceUnlockResponse::GetDataLength() const
  10262. {
  10263.   PINDEX length = 0;
  10264.   length += m_result.GetObjectLength();
  10265.   return length;
  10266. }
  10267.  
  10268.  
  10269. BOOL GCC_ConferenceUnlockResponse::Decode(PASN_Stream & strm)
  10270. {
  10271.   if (!PreambleDecode(strm))
  10272.     return FALSE;
  10273.  
  10274.   if (!m_result.Decode(strm))
  10275.     return FALSE;
  10276.  
  10277.   return UnknownExtensionsDecode(strm);
  10278. }
  10279.  
  10280.  
  10281. void GCC_ConferenceUnlockResponse::Encode(PASN_Stream & strm) const
  10282. {
  10283.   PreambleEncode(strm);
  10284.  
  10285.   m_result.Encode(strm);
  10286.  
  10287.   UnknownExtensionsEncode(strm);
  10288. }
  10289.  
  10290.  
  10291. PObject * GCC_ConferenceUnlockResponse::Clone() const
  10292. {
  10293. #ifndef PASN_LEANANDMEAN
  10294.   PAssert(IsClass(GCC_ConferenceUnlockResponse::Class()), PInvalidCast);
  10295. #endif
  10296.   return new GCC_ConferenceUnlockResponse(*this);
  10297. }
  10298.  
  10299.  
  10300. //
  10301. // ConferenceTerminateRequest
  10302. //
  10303.  
  10304. GCC_ConferenceTerminateRequest::GCC_ConferenceTerminateRequest(unsigned tag, PASN_Object::TagClass tagClass)
  10305.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  10306. {
  10307. }
  10308.  
  10309.  
  10310. #ifndef PASN_NOPRINTON
  10311. void GCC_ConferenceTerminateRequest::PrintOn(ostream & strm) const
  10312. {
  10313.   int indent = strm.precision() + 2;
  10314.   strm << "{\n";
  10315.   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  10316.   strm << setw(indent-1) << "}";
  10317. }
  10318. #endif
  10319.  
  10320.  
  10321. PObject::Comparison GCC_ConferenceTerminateRequest::Compare(const PObject & obj) const
  10322. {
  10323. #ifndef PASN_LEANANDMEAN
  10324.   PAssert(IsDescendant(GCC_ConferenceTerminateRequest::Class()), PInvalidCast);
  10325. #endif
  10326.   const GCC_ConferenceTerminateRequest & other = (const GCC_ConferenceTerminateRequest &)obj;
  10327.  
  10328.   Comparison result;
  10329.  
  10330.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  10331.     return result;
  10332.  
  10333.   return PASN_Sequence::Compare(other);
  10334. }
  10335.  
  10336.  
  10337. PINDEX GCC_ConferenceTerminateRequest::GetDataLength() const
  10338. {
  10339.   PINDEX length = 0;
  10340.   length += m_reason.GetObjectLength();
  10341.   return length;
  10342. }
  10343.  
  10344.  
  10345. BOOL GCC_ConferenceTerminateRequest::Decode(PASN_Stream & strm)
  10346. {
  10347.   if (!PreambleDecode(strm))
  10348.     return FALSE;
  10349.  
  10350.   if (!m_reason.Decode(strm))
  10351.     return FALSE;
  10352.  
  10353.   return UnknownExtensionsDecode(strm);
  10354. }
  10355.  
  10356.  
  10357. void GCC_ConferenceTerminateRequest::Encode(PASN_Stream & strm) const
  10358. {
  10359.   PreambleEncode(strm);
  10360.  
  10361.   m_reason.Encode(strm);
  10362.  
  10363.   UnknownExtensionsEncode(strm);
  10364. }
  10365.  
  10366.  
  10367. PObject * GCC_ConferenceTerminateRequest::Clone() const
  10368. {
  10369. #ifndef PASN_LEANANDMEAN
  10370.   PAssert(IsClass(GCC_ConferenceTerminateRequest::Class()), PInvalidCast);
  10371. #endif
  10372.   return new GCC_ConferenceTerminateRequest(*this);
  10373. }
  10374.  
  10375.  
  10376. //
  10377. // ConferenceTerminateResponse
  10378. //
  10379.  
  10380. GCC_ConferenceTerminateResponse::GCC_ConferenceTerminateResponse(unsigned tag, PASN_Object::TagClass tagClass)
  10381.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  10382. {
  10383. }
  10384.  
  10385.  
  10386. #ifndef PASN_NOPRINTON
  10387. void GCC_ConferenceTerminateResponse::PrintOn(ostream & strm) const
  10388. {
  10389.   int indent = strm.precision() + 2;
  10390.   strm << "{\n";
  10391.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  10392.   strm << setw(indent-1) << "}";
  10393. }
  10394. #endif
  10395.  
  10396.  
  10397. PObject::Comparison GCC_ConferenceTerminateResponse::Compare(const PObject & obj) const
  10398. {
  10399. #ifndef PASN_LEANANDMEAN
  10400.   PAssert(IsDescendant(GCC_ConferenceTerminateResponse::Class()), PInvalidCast);
  10401. #endif
  10402.   const GCC_ConferenceTerminateResponse & other = (const GCC_ConferenceTerminateResponse &)obj;
  10403.  
  10404.   Comparison result;
  10405.  
  10406.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  10407.     return result;
  10408.  
  10409.   return PASN_Sequence::Compare(other);
  10410. }
  10411.  
  10412.  
  10413. PINDEX GCC_ConferenceTerminateResponse::GetDataLength() const
  10414. {
  10415.   PINDEX length = 0;
  10416.   length += m_result.GetObjectLength();
  10417.   return length;
  10418. }
  10419.  
  10420.  
  10421. BOOL GCC_ConferenceTerminateResponse::Decode(PASN_Stream & strm)
  10422. {
  10423.   if (!PreambleDecode(strm))
  10424.     return FALSE;
  10425.  
  10426.   if (!m_result.Decode(strm))
  10427.     return FALSE;
  10428.  
  10429.   return UnknownExtensionsDecode(strm);
  10430. }
  10431.  
  10432.  
  10433. void GCC_ConferenceTerminateResponse::Encode(PASN_Stream & strm) const
  10434. {
  10435.   PreambleEncode(strm);
  10436.  
  10437.   m_result.Encode(strm);
  10438.  
  10439.   UnknownExtensionsEncode(strm);
  10440. }
  10441.  
  10442.  
  10443. PObject * GCC_ConferenceTerminateResponse::Clone() const
  10444. {
  10445. #ifndef PASN_LEANANDMEAN
  10446.   PAssert(IsClass(GCC_ConferenceTerminateResponse::Class()), PInvalidCast);
  10447. #endif
  10448.   return new GCC_ConferenceTerminateResponse(*this);
  10449. }
  10450.  
  10451.  
  10452. //
  10453. // ConferenceTerminateIndication
  10454. //
  10455.  
  10456. GCC_ConferenceTerminateIndication::GCC_ConferenceTerminateIndication(unsigned tag, PASN_Object::TagClass tagClass)
  10457.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  10458. {
  10459. }
  10460.  
  10461.  
  10462. #ifndef PASN_NOPRINTON
  10463. void GCC_ConferenceTerminateIndication::PrintOn(ostream & strm) const
  10464. {
  10465.   int indent = strm.precision() + 2;
  10466.   strm << "{\n";
  10467.   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  10468.   strm << setw(indent-1) << "}";
  10469. }
  10470. #endif
  10471.  
  10472.  
  10473. PObject::Comparison GCC_ConferenceTerminateIndication::Compare(const PObject & obj) const
  10474. {
  10475. #ifndef PASN_LEANANDMEAN
  10476.   PAssert(IsDescendant(GCC_ConferenceTerminateIndication::Class()), PInvalidCast);
  10477. #endif
  10478.   const GCC_ConferenceTerminateIndication & other = (const GCC_ConferenceTerminateIndication &)obj;
  10479.  
  10480.   Comparison result;
  10481.  
  10482.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  10483.     return result;
  10484.  
  10485.   return PASN_Sequence::Compare(other);
  10486. }
  10487.  
  10488.  
  10489. PINDEX GCC_ConferenceTerminateIndication::GetDataLength() const
  10490. {
  10491.   PINDEX length = 0;
  10492.   length += m_reason.GetObjectLength();
  10493.   return length;
  10494. }
  10495.  
  10496.  
  10497. BOOL GCC_ConferenceTerminateIndication::Decode(PASN_Stream & strm)
  10498. {
  10499.   if (!PreambleDecode(strm))
  10500.     return FALSE;
  10501.  
  10502.   if (!m_reason.Decode(strm))
  10503.     return FALSE;
  10504.  
  10505.   return UnknownExtensionsDecode(strm);
  10506. }
  10507.  
  10508.  
  10509. void GCC_ConferenceTerminateIndication::Encode(PASN_Stream & strm) const
  10510. {
  10511.   PreambleEncode(strm);
  10512.  
  10513.   m_reason.Encode(strm);
  10514.  
  10515.   UnknownExtensionsEncode(strm);
  10516. }
  10517.  
  10518.  
  10519. PObject * GCC_ConferenceTerminateIndication::Clone() const
  10520. {
  10521. #ifndef PASN_LEANANDMEAN
  10522.   PAssert(IsClass(GCC_ConferenceTerminateIndication::Class()), PInvalidCast);
  10523. #endif
  10524.   return new GCC_ConferenceTerminateIndication(*this);
  10525. }
  10526.  
  10527.  
  10528. //
  10529. // ConferenceEjectUserRequest
  10530. //
  10531.  
  10532. GCC_ConferenceEjectUserRequest::GCC_ConferenceEjectUserRequest(unsigned tag, PASN_Object::TagClass tagClass)
  10533.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  10534. {
  10535. }
  10536.  
  10537.  
  10538. #ifndef PASN_NOPRINTON
  10539. void GCC_ConferenceEjectUserRequest::PrintOn(ostream & strm) const
  10540. {
  10541.   int indent = strm.precision() + 2;
  10542.   strm << "{\n";
  10543.   strm << setw(indent+14) << "nodeToEject = " << setprecision(indent) << m_nodeToEject << '\n';
  10544.   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  10545.   strm << setw(indent-1) << "}";
  10546. }
  10547. #endif
  10548.  
  10549.  
  10550. PObject::Comparison GCC_ConferenceEjectUserRequest::Compare(const PObject & obj) const
  10551. {
  10552. #ifndef PASN_LEANANDMEAN
  10553.   PAssert(IsDescendant(GCC_ConferenceEjectUserRequest::Class()), PInvalidCast);
  10554. #endif
  10555.   const GCC_ConferenceEjectUserRequest & other = (const GCC_ConferenceEjectUserRequest &)obj;
  10556.  
  10557.   Comparison result;
  10558.  
  10559.   if ((result = m_nodeToEject.Compare(other.m_nodeToEject)) != EqualTo)
  10560.     return result;
  10561.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  10562.     return result;
  10563.  
  10564.   return PASN_Sequence::Compare(other);
  10565. }
  10566.  
  10567.  
  10568. PINDEX GCC_ConferenceEjectUserRequest::GetDataLength() const
  10569. {
  10570.   PINDEX length = 0;
  10571.   length += m_nodeToEject.GetObjectLength();
  10572.   length += m_reason.GetObjectLength();
  10573.   return length;
  10574. }
  10575.  
  10576.  
  10577. BOOL GCC_ConferenceEjectUserRequest::Decode(PASN_Stream & strm)
  10578. {
  10579.   if (!PreambleDecode(strm))
  10580.     return FALSE;
  10581.  
  10582.   if (!m_nodeToEject.Decode(strm))
  10583.     return FALSE;
  10584.   if (!m_reason.Decode(strm))
  10585.     return FALSE;
  10586.  
  10587.   return UnknownExtensionsDecode(strm);
  10588. }
  10589.  
  10590.  
  10591. void GCC_ConferenceEjectUserRequest::Encode(PASN_Stream & strm) const
  10592. {
  10593.   PreambleEncode(strm);
  10594.  
  10595.   m_nodeToEject.Encode(strm);
  10596.   m_reason.Encode(strm);
  10597.  
  10598.   UnknownExtensionsEncode(strm);
  10599. }
  10600.  
  10601.  
  10602. PObject * GCC_ConferenceEjectUserRequest::Clone() const
  10603. {
  10604. #ifndef PASN_LEANANDMEAN
  10605.   PAssert(IsClass(GCC_ConferenceEjectUserRequest::Class()), PInvalidCast);
  10606. #endif
  10607.   return new GCC_ConferenceEjectUserRequest(*this);
  10608. }
  10609.  
  10610.  
  10611. //
  10612. // ConferenceEjectUserResponse
  10613. //
  10614.  
  10615. GCC_ConferenceEjectUserResponse::GCC_ConferenceEjectUserResponse(unsigned tag, PASN_Object::TagClass tagClass)
  10616.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  10617. {
  10618. }
  10619.  
  10620.  
  10621. #ifndef PASN_NOPRINTON
  10622. void GCC_ConferenceEjectUserResponse::PrintOn(ostream & strm) const
  10623. {
  10624.   int indent = strm.precision() + 2;
  10625.   strm << "{\n";
  10626.   strm << setw(indent+14) << "nodeToEject = " << setprecision(indent) << m_nodeToEject << '\n';
  10627.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  10628.   strm << setw(indent-1) << "}";
  10629. }
  10630. #endif
  10631.  
  10632.  
  10633. PObject::Comparison GCC_ConferenceEjectUserResponse::Compare(const PObject & obj) const
  10634. {
  10635. #ifndef PASN_LEANANDMEAN
  10636.   PAssert(IsDescendant(GCC_ConferenceEjectUserResponse::Class()), PInvalidCast);
  10637. #endif
  10638.   const GCC_ConferenceEjectUserResponse & other = (const GCC_ConferenceEjectUserResponse &)obj;
  10639.  
  10640.   Comparison result;
  10641.  
  10642.   if ((result = m_nodeToEject.Compare(other.m_nodeToEject)) != EqualTo)
  10643.     return result;
  10644.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  10645.     return result;
  10646.  
  10647.   return PASN_Sequence::Compare(other);
  10648. }
  10649.  
  10650.  
  10651. PINDEX GCC_ConferenceEjectUserResponse::GetDataLength() const
  10652. {
  10653.   PINDEX length = 0;
  10654.   length += m_nodeToEject.GetObjectLength();
  10655.   length += m_result.GetObjectLength();
  10656.   return length;
  10657. }
  10658.  
  10659.  
  10660. BOOL GCC_ConferenceEjectUserResponse::Decode(PASN_Stream & strm)
  10661. {
  10662.   if (!PreambleDecode(strm))
  10663.     return FALSE;
  10664.  
  10665.   if (!m_nodeToEject.Decode(strm))
  10666.     return FALSE;
  10667.   if (!m_result.Decode(strm))
  10668.     return FALSE;
  10669.  
  10670.   return UnknownExtensionsDecode(strm);
  10671. }
  10672.  
  10673.  
  10674. void GCC_ConferenceEjectUserResponse::Encode(PASN_Stream & strm) const
  10675. {
  10676.   PreambleEncode(strm);
  10677.  
  10678.   m_nodeToEject.Encode(strm);
  10679.   m_result.Encode(strm);
  10680.  
  10681.   UnknownExtensionsEncode(strm);
  10682. }
  10683.  
  10684.  
  10685. PObject * GCC_ConferenceEjectUserResponse::Clone() const
  10686. {
  10687. #ifndef PASN_LEANANDMEAN
  10688.   PAssert(IsClass(GCC_ConferenceEjectUserResponse::Class()), PInvalidCast);
  10689. #endif
  10690.   return new GCC_ConferenceEjectUserResponse(*this);
  10691. }
  10692.  
  10693.  
  10694. //
  10695. // ConferenceEjectUserIndication
  10696. //
  10697.  
  10698. GCC_ConferenceEjectUserIndication::GCC_ConferenceEjectUserIndication(unsigned tag, PASN_Object::TagClass tagClass)
  10699.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  10700. {
  10701. }
  10702.  
  10703.  
  10704. #ifndef PASN_NOPRINTON
  10705. void GCC_ConferenceEjectUserIndication::PrintOn(ostream & strm) const
  10706. {
  10707.   int indent = strm.precision() + 2;
  10708.   strm << "{\n";
  10709.   strm << setw(indent+14) << "nodeToEject = " << setprecision(indent) << m_nodeToEject << '\n';
  10710.   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  10711.   strm << setw(indent-1) << "}";
  10712. }
  10713. #endif
  10714.  
  10715.  
  10716. PObject::Comparison GCC_ConferenceEjectUserIndication::Compare(const PObject & obj) const
  10717. {
  10718. #ifndef PASN_LEANANDMEAN
  10719.   PAssert(IsDescendant(GCC_ConferenceEjectUserIndication::Class()), PInvalidCast);
  10720. #endif
  10721.   const GCC_ConferenceEjectUserIndication & other = (const GCC_ConferenceEjectUserIndication &)obj;
  10722.  
  10723.   Comparison result;
  10724.  
  10725.   if ((result = m_nodeToEject.Compare(other.m_nodeToEject)) != EqualTo)
  10726.     return result;
  10727.   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
  10728.     return result;
  10729.  
  10730.   return PASN_Sequence::Compare(other);
  10731. }
  10732.  
  10733.  
  10734. PINDEX GCC_ConferenceEjectUserIndication::GetDataLength() const
  10735. {
  10736.   PINDEX length = 0;
  10737.   length += m_nodeToEject.GetObjectLength();
  10738.   length += m_reason.GetObjectLength();
  10739.   return length;
  10740. }
  10741.  
  10742.  
  10743. BOOL GCC_ConferenceEjectUserIndication::Decode(PASN_Stream & strm)
  10744. {
  10745.   if (!PreambleDecode(strm))
  10746.     return FALSE;
  10747.  
  10748.   if (!m_nodeToEject.Decode(strm))
  10749.     return FALSE;
  10750.   if (!m_reason.Decode(strm))
  10751.     return FALSE;
  10752.  
  10753.   return UnknownExtensionsDecode(strm);
  10754. }
  10755.  
  10756.  
  10757. void GCC_ConferenceEjectUserIndication::Encode(PASN_Stream & strm) const
  10758. {
  10759.   PreambleEncode(strm);
  10760.  
  10761.   m_nodeToEject.Encode(strm);
  10762.   m_reason.Encode(strm);
  10763.  
  10764.   UnknownExtensionsEncode(strm);
  10765. }
  10766.  
  10767.  
  10768. PObject * GCC_ConferenceEjectUserIndication::Clone() const
  10769. {
  10770. #ifndef PASN_LEANANDMEAN
  10771.   PAssert(IsClass(GCC_ConferenceEjectUserIndication::Class()), PInvalidCast);
  10772. #endif
  10773.   return new GCC_ConferenceEjectUserIndication(*this);
  10774. }
  10775.  
  10776.  
  10777. //
  10778. // ConferenceTransferRequest
  10779. //
  10780.  
  10781. GCC_ConferenceTransferRequest::GCC_ConferenceTransferRequest(unsigned tag, PASN_Object::TagClass tagClass)
  10782.   : PASN_Sequence(tag, tagClass, 4, TRUE, 0)
  10783. {
  10784.   m_transferringNodes.SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  10785. }
  10786.  
  10787.  
  10788. #ifndef PASN_NOPRINTON
  10789. void GCC_ConferenceTransferRequest::PrintOn(ostream & strm) const
  10790. {
  10791.   int indent = strm.precision() + 2;
  10792.   strm << "{\n";
  10793.   strm << setw(indent+17) << "conferenceName = " << setprecision(indent) << m_conferenceName << '\n';
  10794.   if (HasOptionalField(e_conferenceNameModifier))
  10795.     strm << setw(indent+25) << "conferenceNameModifier = " << setprecision(indent) << m_conferenceNameModifier << '\n';
  10796.   if (HasOptionalField(e_networkAddress))
  10797.     strm << setw(indent+17) << "networkAddress = " << setprecision(indent) << m_networkAddress << '\n';
  10798.   if (HasOptionalField(e_transferringNodes))
  10799.     strm << setw(indent+20) << "transferringNodes = " << setprecision(indent) << m_transferringNodes << '\n';
  10800.   if (HasOptionalField(e_password))
  10801.     strm << setw(indent+11) << "password = " << setprecision(indent) << m_password << '\n';
  10802.   strm << setw(indent-1) << "}";
  10803. }
  10804. #endif
  10805.  
  10806.  
  10807. PObject::Comparison GCC_ConferenceTransferRequest::Compare(const PObject & obj) const
  10808. {
  10809. #ifndef PASN_LEANANDMEAN
  10810.   PAssert(IsDescendant(GCC_ConferenceTransferRequest::Class()), PInvalidCast);
  10811. #endif
  10812.   const GCC_ConferenceTransferRequest & other = (const GCC_ConferenceTransferRequest &)obj;
  10813.  
  10814.   Comparison result;
  10815.  
  10816.   if ((result = m_conferenceName.Compare(other.m_conferenceName)) != EqualTo)
  10817.     return result;
  10818.   if ((result = m_conferenceNameModifier.Compare(other.m_conferenceNameModifier)) != EqualTo)
  10819.     return result;
  10820.   if ((result = m_networkAddress.Compare(other.m_networkAddress)) != EqualTo)
  10821.     return result;
  10822.   if ((result = m_transferringNodes.Compare(other.m_transferringNodes)) != EqualTo)
  10823.     return result;
  10824.   if ((result = m_password.Compare(other.m_password)) != EqualTo)
  10825.     return result;
  10826.  
  10827.   return PASN_Sequence::Compare(other);
  10828. }
  10829.  
  10830.  
  10831. PINDEX GCC_ConferenceTransferRequest::GetDataLength() const
  10832. {
  10833.   PINDEX length = 0;
  10834.   length += m_conferenceName.GetObjectLength();
  10835.   if (HasOptionalField(e_conferenceNameModifier))
  10836.     length += m_conferenceNameModifier.GetObjectLength();
  10837.   if (HasOptionalField(e_networkAddress))
  10838.     length += m_networkAddress.GetObjectLength();
  10839.   if (HasOptionalField(e_transferringNodes))
  10840.     length += m_transferringNodes.GetObjectLength();
  10841.   if (HasOptionalField(e_password))
  10842.     length += m_password.GetObjectLength();
  10843.   return length;
  10844. }
  10845.  
  10846.  
  10847. BOOL GCC_ConferenceTransferRequest::Decode(PASN_Stream & strm)
  10848. {
  10849.   if (!PreambleDecode(strm))
  10850.     return FALSE;
  10851.  
  10852.   if (!m_conferenceName.Decode(strm))
  10853.     return FALSE;
  10854.   if (HasOptionalField(e_conferenceNameModifier) && !m_conferenceNameModifier.Decode(strm))
  10855.     return FALSE;
  10856.   if (HasOptionalField(e_networkAddress) && !m_networkAddress.Decode(strm))
  10857.     return FALSE;
  10858.   if (HasOptionalField(e_transferringNodes) && !m_transferringNodes.Decode(strm))
  10859.     return FALSE;
  10860.   if (HasOptionalField(e_password) && !m_password.Decode(strm))
  10861.     return FALSE;
  10862.  
  10863.   return UnknownExtensionsDecode(strm);
  10864. }
  10865.  
  10866.  
  10867. void GCC_ConferenceTransferRequest::Encode(PASN_Stream & strm) const
  10868. {
  10869.   PreambleEncode(strm);
  10870.  
  10871.   m_conferenceName.Encode(strm);
  10872.   if (HasOptionalField(e_conferenceNameModifier))
  10873.     m_conferenceNameModifier.Encode(strm);
  10874.   if (HasOptionalField(e_networkAddress))
  10875.     m_networkAddress.Encode(strm);
  10876.   if (HasOptionalField(e_transferringNodes))
  10877.     m_transferringNodes.Encode(strm);
  10878.   if (HasOptionalField(e_password))
  10879.     m_password.Encode(strm);
  10880.  
  10881.   UnknownExtensionsEncode(strm);
  10882. }
  10883.  
  10884.  
  10885. PObject * GCC_ConferenceTransferRequest::Clone() const
  10886. {
  10887. #ifndef PASN_LEANANDMEAN
  10888.   PAssert(IsClass(GCC_ConferenceTransferRequest::Class()), PInvalidCast);
  10889. #endif
  10890.   return new GCC_ConferenceTransferRequest(*this);
  10891. }
  10892.  
  10893.  
  10894. //
  10895. // ConferenceTransferResponse
  10896. //
  10897.  
  10898. GCC_ConferenceTransferResponse::GCC_ConferenceTransferResponse(unsigned tag, PASN_Object::TagClass tagClass)
  10899.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  10900. {
  10901.   m_transferringNodes.SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  10902. }
  10903.  
  10904.  
  10905. #ifndef PASN_NOPRINTON
  10906. void GCC_ConferenceTransferResponse::PrintOn(ostream & strm) const
  10907. {
  10908.   int indent = strm.precision() + 2;
  10909.   strm << "{\n";
  10910.   strm << setw(indent+17) << "conferenceName = " << setprecision(indent) << m_conferenceName << '\n';
  10911.   if (HasOptionalField(e_conferenceNameModifier))
  10912.     strm << setw(indent+25) << "conferenceNameModifier = " << setprecision(indent) << m_conferenceNameModifier << '\n';
  10913.   if (HasOptionalField(e_transferringNodes))
  10914.     strm << setw(indent+20) << "transferringNodes = " << setprecision(indent) << m_transferringNodes << '\n';
  10915.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  10916.   strm << setw(indent-1) << "}";
  10917. }
  10918. #endif
  10919.  
  10920.  
  10921. PObject::Comparison GCC_ConferenceTransferResponse::Compare(const PObject & obj) const
  10922. {
  10923. #ifndef PASN_LEANANDMEAN
  10924.   PAssert(IsDescendant(GCC_ConferenceTransferResponse::Class()), PInvalidCast);
  10925. #endif
  10926.   const GCC_ConferenceTransferResponse & other = (const GCC_ConferenceTransferResponse &)obj;
  10927.  
  10928.   Comparison result;
  10929.  
  10930.   if ((result = m_conferenceName.Compare(other.m_conferenceName)) != EqualTo)
  10931.     return result;
  10932.   if ((result = m_conferenceNameModifier.Compare(other.m_conferenceNameModifier)) != EqualTo)
  10933.     return result;
  10934.   if ((result = m_transferringNodes.Compare(other.m_transferringNodes)) != EqualTo)
  10935.     return result;
  10936.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  10937.     return result;
  10938.  
  10939.   return PASN_Sequence::Compare(other);
  10940. }
  10941.  
  10942.  
  10943. PINDEX GCC_ConferenceTransferResponse::GetDataLength() const
  10944. {
  10945.   PINDEX length = 0;
  10946.   length += m_conferenceName.GetObjectLength();
  10947.   if (HasOptionalField(e_conferenceNameModifier))
  10948.     length += m_conferenceNameModifier.GetObjectLength();
  10949.   if (HasOptionalField(e_transferringNodes))
  10950.     length += m_transferringNodes.GetObjectLength();
  10951.   length += m_result.GetObjectLength();
  10952.   return length;
  10953. }
  10954.  
  10955.  
  10956. BOOL GCC_ConferenceTransferResponse::Decode(PASN_Stream & strm)
  10957. {
  10958.   if (!PreambleDecode(strm))
  10959.     return FALSE;
  10960.  
  10961.   if (!m_conferenceName.Decode(strm))
  10962.     return FALSE;
  10963.   if (HasOptionalField(e_conferenceNameModifier) && !m_conferenceNameModifier.Decode(strm))
  10964.     return FALSE;
  10965.   if (HasOptionalField(e_transferringNodes) && !m_transferringNodes.Decode(strm))
  10966.     return FALSE;
  10967.   if (!m_result.Decode(strm))
  10968.     return FALSE;
  10969.  
  10970.   return UnknownExtensionsDecode(strm);
  10971. }
  10972.  
  10973.  
  10974. void GCC_ConferenceTransferResponse::Encode(PASN_Stream & strm) const
  10975. {
  10976.   PreambleEncode(strm);
  10977.  
  10978.   m_conferenceName.Encode(strm);
  10979.   if (HasOptionalField(e_conferenceNameModifier))
  10980.     m_conferenceNameModifier.Encode(strm);
  10981.   if (HasOptionalField(e_transferringNodes))
  10982.     m_transferringNodes.Encode(strm);
  10983.   m_result.Encode(strm);
  10984.  
  10985.   UnknownExtensionsEncode(strm);
  10986. }
  10987.  
  10988.  
  10989. PObject * GCC_ConferenceTransferResponse::Clone() const
  10990. {
  10991. #ifndef PASN_LEANANDMEAN
  10992.   PAssert(IsClass(GCC_ConferenceTransferResponse::Class()), PInvalidCast);
  10993. #endif
  10994.   return new GCC_ConferenceTransferResponse(*this);
  10995. }
  10996.  
  10997.  
  10998. //
  10999. // ConferenceTransferIndication
  11000. //
  11001.  
  11002. GCC_ConferenceTransferIndication::GCC_ConferenceTransferIndication(unsigned tag, PASN_Object::TagClass tagClass)
  11003.   : PASN_Sequence(tag, tagClass, 4, TRUE, 0)
  11004. {
  11005.   m_transferringNodes.SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  11006. }
  11007.  
  11008.  
  11009. #ifndef PASN_NOPRINTON
  11010. void GCC_ConferenceTransferIndication::PrintOn(ostream & strm) const
  11011. {
  11012.   int indent = strm.precision() + 2;
  11013.   strm << "{\n";
  11014.   strm << setw(indent+17) << "conferenceName = " << setprecision(indent) << m_conferenceName << '\n';
  11015.   if (HasOptionalField(e_conferenceNameModifier))
  11016.     strm << setw(indent+25) << "conferenceNameModifier = " << setprecision(indent) << m_conferenceNameModifier << '\n';
  11017.   if (HasOptionalField(e_networkAddress))
  11018.     strm << setw(indent+17) << "networkAddress = " << setprecision(indent) << m_networkAddress << '\n';
  11019.   if (HasOptionalField(e_transferringNodes))
  11020.     strm << setw(indent+20) << "transferringNodes = " << setprecision(indent) << m_transferringNodes << '\n';
  11021.   if (HasOptionalField(e_password))
  11022.     strm << setw(indent+11) << "password = " << setprecision(indent) << m_password << '\n';
  11023.   strm << setw(indent-1) << "}";
  11024. }
  11025. #endif
  11026.  
  11027.  
  11028. PObject::Comparison GCC_ConferenceTransferIndication::Compare(const PObject & obj) const
  11029. {
  11030. #ifndef PASN_LEANANDMEAN
  11031.   PAssert(IsDescendant(GCC_ConferenceTransferIndication::Class()), PInvalidCast);
  11032. #endif
  11033.   const GCC_ConferenceTransferIndication & other = (const GCC_ConferenceTransferIndication &)obj;
  11034.  
  11035.   Comparison result;
  11036.  
  11037.   if ((result = m_conferenceName.Compare(other.m_conferenceName)) != EqualTo)
  11038.     return result;
  11039.   if ((result = m_conferenceNameModifier.Compare(other.m_conferenceNameModifier)) != EqualTo)
  11040.     return result;
  11041.   if ((result = m_networkAddress.Compare(other.m_networkAddress)) != EqualTo)
  11042.     return result;
  11043.   if ((result = m_transferringNodes.Compare(other.m_transferringNodes)) != EqualTo)
  11044.     return result;
  11045.   if ((result = m_password.Compare(other.m_password)) != EqualTo)
  11046.     return result;
  11047.  
  11048.   return PASN_Sequence::Compare(other);
  11049. }
  11050.  
  11051.  
  11052. PINDEX GCC_ConferenceTransferIndication::GetDataLength() const
  11053. {
  11054.   PINDEX length = 0;
  11055.   length += m_conferenceName.GetObjectLength();
  11056.   if (HasOptionalField(e_conferenceNameModifier))
  11057.     length += m_conferenceNameModifier.GetObjectLength();
  11058.   if (HasOptionalField(e_networkAddress))
  11059.     length += m_networkAddress.GetObjectLength();
  11060.   if (HasOptionalField(e_transferringNodes))
  11061.     length += m_transferringNodes.GetObjectLength();
  11062.   if (HasOptionalField(e_password))
  11063.     length += m_password.GetObjectLength();
  11064.   return length;
  11065. }
  11066.  
  11067.  
  11068. BOOL GCC_ConferenceTransferIndication::Decode(PASN_Stream & strm)
  11069. {
  11070.   if (!PreambleDecode(strm))
  11071.     return FALSE;
  11072.  
  11073.   if (!m_conferenceName.Decode(strm))
  11074.     return FALSE;
  11075.   if (HasOptionalField(e_conferenceNameModifier) && !m_conferenceNameModifier.Decode(strm))
  11076.     return FALSE;
  11077.   if (HasOptionalField(e_networkAddress) && !m_networkAddress.Decode(strm))
  11078.     return FALSE;
  11079.   if (HasOptionalField(e_transferringNodes) && !m_transferringNodes.Decode(strm))
  11080.     return FALSE;
  11081.   if (HasOptionalField(e_password) && !m_password.Decode(strm))
  11082.     return FALSE;
  11083.  
  11084.   return UnknownExtensionsDecode(strm);
  11085. }
  11086.  
  11087.  
  11088. void GCC_ConferenceTransferIndication::Encode(PASN_Stream & strm) const
  11089. {
  11090.   PreambleEncode(strm);
  11091.  
  11092.   m_conferenceName.Encode(strm);
  11093.   if (HasOptionalField(e_conferenceNameModifier))
  11094.     m_conferenceNameModifier.Encode(strm);
  11095.   if (HasOptionalField(e_networkAddress))
  11096.     m_networkAddress.Encode(strm);
  11097.   if (HasOptionalField(e_transferringNodes))
  11098.     m_transferringNodes.Encode(strm);
  11099.   if (HasOptionalField(e_password))
  11100.     m_password.Encode(strm);
  11101.  
  11102.   UnknownExtensionsEncode(strm);
  11103. }
  11104.  
  11105.  
  11106. PObject * GCC_ConferenceTransferIndication::Clone() const
  11107. {
  11108. #ifndef PASN_LEANANDMEAN
  11109.   PAssert(IsClass(GCC_ConferenceTransferIndication::Class()), PInvalidCast);
  11110. #endif
  11111.   return new GCC_ConferenceTransferIndication(*this);
  11112. }
  11113.  
  11114.  
  11115. //
  11116. // ApplicationInvokeIndication
  11117. //
  11118.  
  11119. GCC_ApplicationInvokeIndication::GCC_ApplicationInvokeIndication(unsigned tag, PASN_Object::TagClass tagClass)
  11120.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  11121. {
  11122.   m_applicationProtocolEntiyList.SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  11123.   m_destinationNodes.SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  11124. }
  11125.  
  11126.  
  11127. #ifndef PASN_NOPRINTON
  11128. void GCC_ApplicationInvokeIndication::PrintOn(ostream & strm) const
  11129. {
  11130.   int indent = strm.precision() + 2;
  11131.   strm << "{\n";
  11132.   strm << setw(indent+31) << "applicationProtocolEntiyList = " << setprecision(indent) << m_applicationProtocolEntiyList << '\n';
  11133.   if (HasOptionalField(e_destinationNodes))
  11134.     strm << setw(indent+19) << "destinationNodes = " << setprecision(indent) << m_destinationNodes << '\n';
  11135.   strm << setw(indent-1) << "}";
  11136. }
  11137. #endif
  11138.  
  11139.  
  11140. PObject::Comparison GCC_ApplicationInvokeIndication::Compare(const PObject & obj) const
  11141. {
  11142. #ifndef PASN_LEANANDMEAN
  11143.   PAssert(IsDescendant(GCC_ApplicationInvokeIndication::Class()), PInvalidCast);
  11144. #endif
  11145.   const GCC_ApplicationInvokeIndication & other = (const GCC_ApplicationInvokeIndication &)obj;
  11146.  
  11147.   Comparison result;
  11148.  
  11149.   if ((result = m_applicationProtocolEntiyList.Compare(other.m_applicationProtocolEntiyList)) != EqualTo)
  11150.     return result;
  11151.   if ((result = m_destinationNodes.Compare(other.m_destinationNodes)) != EqualTo)
  11152.     return result;
  11153.  
  11154.   return PASN_Sequence::Compare(other);
  11155. }
  11156.  
  11157.  
  11158. PINDEX GCC_ApplicationInvokeIndication::GetDataLength() const
  11159. {
  11160.   PINDEX length = 0;
  11161.   length += m_applicationProtocolEntiyList.GetObjectLength();
  11162.   if (HasOptionalField(e_destinationNodes))
  11163.     length += m_destinationNodes.GetObjectLength();
  11164.   return length;
  11165. }
  11166.  
  11167.  
  11168. BOOL GCC_ApplicationInvokeIndication::Decode(PASN_Stream & strm)
  11169. {
  11170.   if (!PreambleDecode(strm))
  11171.     return FALSE;
  11172.  
  11173.   if (!m_applicationProtocolEntiyList.Decode(strm))
  11174.     return FALSE;
  11175.   if (HasOptionalField(e_destinationNodes) && !m_destinationNodes.Decode(strm))
  11176.     return FALSE;
  11177.  
  11178.   return UnknownExtensionsDecode(strm);
  11179. }
  11180.  
  11181.  
  11182. void GCC_ApplicationInvokeIndication::Encode(PASN_Stream & strm) const
  11183. {
  11184.   PreambleEncode(strm);
  11185.  
  11186.   m_applicationProtocolEntiyList.Encode(strm);
  11187.   if (HasOptionalField(e_destinationNodes))
  11188.     m_destinationNodes.Encode(strm);
  11189.  
  11190.   UnknownExtensionsEncode(strm);
  11191. }
  11192.  
  11193.  
  11194. PObject * GCC_ApplicationInvokeIndication::Clone() const
  11195. {
  11196. #ifndef PASN_LEANANDMEAN
  11197.   PAssert(IsClass(GCC_ApplicationInvokeIndication::Class()), PInvalidCast);
  11198. #endif
  11199.   return new GCC_ApplicationInvokeIndication(*this);
  11200. }
  11201.  
  11202.  
  11203. //
  11204. // RegistryAllocateHandleResponse
  11205. //
  11206.  
  11207. GCC_RegistryAllocateHandleResponse::GCC_RegistryAllocateHandleResponse(unsigned tag, PASN_Object::TagClass tagClass)
  11208.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  11209. {
  11210.   m_numberOfHandles.SetConstraints(PASN_Object::FixedConstraint, 1, 1024);
  11211. }
  11212.  
  11213.  
  11214. #ifndef PASN_NOPRINTON
  11215. void GCC_RegistryAllocateHandleResponse::PrintOn(ostream & strm) const
  11216. {
  11217.   int indent = strm.precision() + 2;
  11218.   strm << "{\n";
  11219.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  11220.   strm << setw(indent+18) << "numberOfHandles = " << setprecision(indent) << m_numberOfHandles << '\n';
  11221.   strm << setw(indent+14) << "firstHandle = " << setprecision(indent) << m_firstHandle << '\n';
  11222.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  11223.   strm << setw(indent-1) << "}";
  11224. }
  11225. #endif
  11226.  
  11227.  
  11228. PObject::Comparison GCC_RegistryAllocateHandleResponse::Compare(const PObject & obj) const
  11229. {
  11230. #ifndef PASN_LEANANDMEAN
  11231.   PAssert(IsDescendant(GCC_RegistryAllocateHandleResponse::Class()), PInvalidCast);
  11232. #endif
  11233.   const GCC_RegistryAllocateHandleResponse & other = (const GCC_RegistryAllocateHandleResponse &)obj;
  11234.  
  11235.   Comparison result;
  11236.  
  11237.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  11238.     return result;
  11239.   if ((result = m_numberOfHandles.Compare(other.m_numberOfHandles)) != EqualTo)
  11240.     return result;
  11241.   if ((result = m_firstHandle.Compare(other.m_firstHandle)) != EqualTo)
  11242.     return result;
  11243.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  11244.     return result;
  11245.  
  11246.   return PASN_Sequence::Compare(other);
  11247. }
  11248.  
  11249.  
  11250. PINDEX GCC_RegistryAllocateHandleResponse::GetDataLength() const
  11251. {
  11252.   PINDEX length = 0;
  11253.   length += m_entityID.GetObjectLength();
  11254.   length += m_numberOfHandles.GetObjectLength();
  11255.   length += m_firstHandle.GetObjectLength();
  11256.   length += m_result.GetObjectLength();
  11257.   return length;
  11258. }
  11259.  
  11260.  
  11261. BOOL GCC_RegistryAllocateHandleResponse::Decode(PASN_Stream & strm)
  11262. {
  11263.   if (!PreambleDecode(strm))
  11264.     return FALSE;
  11265.  
  11266.   if (!m_entityID.Decode(strm))
  11267.     return FALSE;
  11268.   if (!m_numberOfHandles.Decode(strm))
  11269.     return FALSE;
  11270.   if (!m_firstHandle.Decode(strm))
  11271.     return FALSE;
  11272.   if (!m_result.Decode(strm))
  11273.     return FALSE;
  11274.  
  11275.   return UnknownExtensionsDecode(strm);
  11276. }
  11277.  
  11278.  
  11279. void GCC_RegistryAllocateHandleResponse::Encode(PASN_Stream & strm) const
  11280. {
  11281.   PreambleEncode(strm);
  11282.  
  11283.   m_entityID.Encode(strm);
  11284.   m_numberOfHandles.Encode(strm);
  11285.   m_firstHandle.Encode(strm);
  11286.   m_result.Encode(strm);
  11287.  
  11288.   UnknownExtensionsEncode(strm);
  11289. }
  11290.  
  11291.  
  11292. PObject * GCC_RegistryAllocateHandleResponse::Clone() const
  11293. {
  11294. #ifndef PASN_LEANANDMEAN
  11295.   PAssert(IsClass(GCC_RegistryAllocateHandleResponse::Class()), PInvalidCast);
  11296. #endif
  11297.   return new GCC_RegistryAllocateHandleResponse(*this);
  11298. }
  11299.  
  11300.  
  11301. //
  11302. // RegistryResponse
  11303. //
  11304.  
  11305. GCC_RegistryResponse::GCC_RegistryResponse(unsigned tag, PASN_Object::TagClass tagClass)
  11306.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  11307. {
  11308. }
  11309.  
  11310.  
  11311. #ifndef PASN_NOPRINTON
  11312. void GCC_RegistryResponse::PrintOn(ostream & strm) const
  11313. {
  11314.   int indent = strm.precision() + 2;
  11315.   strm << "{\n";
  11316.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  11317.   strm << setw(indent+16) << "primitiveType = " << setprecision(indent) << m_primitiveType << '\n';
  11318.   strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  11319.   strm << setw(indent+7) << "item = " << setprecision(indent) << m_item << '\n';
  11320.   strm << setw(indent+8) << "owner = " << setprecision(indent) << m_owner << '\n';
  11321.   if (HasOptionalField(e_modificationRights))
  11322.     strm << setw(indent+21) << "modificationRights = " << setprecision(indent) << m_modificationRights << '\n';
  11323.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  11324.   strm << setw(indent-1) << "}";
  11325. }
  11326. #endif
  11327.  
  11328.  
  11329. PObject::Comparison GCC_RegistryResponse::Compare(const PObject & obj) const
  11330. {
  11331. #ifndef PASN_LEANANDMEAN
  11332.   PAssert(IsDescendant(GCC_RegistryResponse::Class()), PInvalidCast);
  11333. #endif
  11334.   const GCC_RegistryResponse & other = (const GCC_RegistryResponse &)obj;
  11335.  
  11336.   Comparison result;
  11337.  
  11338.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  11339.     return result;
  11340.   if ((result = m_primitiveType.Compare(other.m_primitiveType)) != EqualTo)
  11341.     return result;
  11342.   if ((result = m_key.Compare(other.m_key)) != EqualTo)
  11343.     return result;
  11344.   if ((result = m_item.Compare(other.m_item)) != EqualTo)
  11345.     return result;
  11346.   if ((result = m_owner.Compare(other.m_owner)) != EqualTo)
  11347.     return result;
  11348.   if ((result = m_modificationRights.Compare(other.m_modificationRights)) != EqualTo)
  11349.     return result;
  11350.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  11351.     return result;
  11352.  
  11353.   return PASN_Sequence::Compare(other);
  11354. }
  11355.  
  11356.  
  11357. PINDEX GCC_RegistryResponse::GetDataLength() const
  11358. {
  11359.   PINDEX length = 0;
  11360.   length += m_entityID.GetObjectLength();
  11361.   length += m_primitiveType.GetObjectLength();
  11362.   length += m_key.GetObjectLength();
  11363.   length += m_item.GetObjectLength();
  11364.   length += m_owner.GetObjectLength();
  11365.   if (HasOptionalField(e_modificationRights))
  11366.     length += m_modificationRights.GetObjectLength();
  11367.   length += m_result.GetObjectLength();
  11368.   return length;
  11369. }
  11370.  
  11371.  
  11372. BOOL GCC_RegistryResponse::Decode(PASN_Stream & strm)
  11373. {
  11374.   if (!PreambleDecode(strm))
  11375.     return FALSE;
  11376.  
  11377.   if (!m_entityID.Decode(strm))
  11378.     return FALSE;
  11379.   if (!m_primitiveType.Decode(strm))
  11380.     return FALSE;
  11381.   if (!m_key.Decode(strm))
  11382.     return FALSE;
  11383.   if (!m_item.Decode(strm))
  11384.     return FALSE;
  11385.   if (!m_owner.Decode(strm))
  11386.     return FALSE;
  11387.   if (HasOptionalField(e_modificationRights) && !m_modificationRights.Decode(strm))
  11388.     return FALSE;
  11389.   if (!m_result.Decode(strm))
  11390.     return FALSE;
  11391.  
  11392.   return UnknownExtensionsDecode(strm);
  11393. }
  11394.  
  11395.  
  11396. void GCC_RegistryResponse::Encode(PASN_Stream & strm) const
  11397. {
  11398.   PreambleEncode(strm);
  11399.  
  11400.   m_entityID.Encode(strm);
  11401.   m_primitiveType.Encode(strm);
  11402.   m_key.Encode(strm);
  11403.   m_item.Encode(strm);
  11404.   m_owner.Encode(strm);
  11405.   if (HasOptionalField(e_modificationRights))
  11406.     m_modificationRights.Encode(strm);
  11407.   m_result.Encode(strm);
  11408.  
  11409.   UnknownExtensionsEncode(strm);
  11410. }
  11411.  
  11412.  
  11413. PObject * GCC_RegistryResponse::Clone() const
  11414. {
  11415. #ifndef PASN_LEANANDMEAN
  11416.   PAssert(IsClass(GCC_RegistryResponse::Class()), PInvalidCast);
  11417. #endif
  11418.   return new GCC_RegistryResponse(*this);
  11419. }
  11420.  
  11421.  
  11422. //
  11423. // ConductorPermissionGrantIndication
  11424. //
  11425.  
  11426. GCC_ConductorPermissionGrantIndication::GCC_ConductorPermissionGrantIndication(unsigned tag, PASN_Object::TagClass tagClass)
  11427.   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
  11428. {
  11429.   m_permissionList.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  11430.   m_waitingList.SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
  11431. }
  11432.  
  11433.  
  11434. #ifndef PASN_NOPRINTON
  11435. void GCC_ConductorPermissionGrantIndication::PrintOn(ostream & strm) const
  11436. {
  11437.   int indent = strm.precision() + 2;
  11438.   strm << "{\n";
  11439.   strm << setw(indent+17) << "permissionList = " << setprecision(indent) << m_permissionList << '\n';
  11440.   if (HasOptionalField(e_waitingList))
  11441.     strm << setw(indent+14) << "waitingList = " << setprecision(indent) << m_waitingList << '\n';
  11442.   strm << setw(indent-1) << "}";
  11443. }
  11444. #endif
  11445.  
  11446.  
  11447. PObject::Comparison GCC_ConductorPermissionGrantIndication::Compare(const PObject & obj) const
  11448. {
  11449. #ifndef PASN_LEANANDMEAN
  11450.   PAssert(IsDescendant(GCC_ConductorPermissionGrantIndication::Class()), PInvalidCast);
  11451. #endif
  11452.   const GCC_ConductorPermissionGrantIndication & other = (const GCC_ConductorPermissionGrantIndication &)obj;
  11453.  
  11454.   Comparison result;
  11455.  
  11456.   if ((result = m_permissionList.Compare(other.m_permissionList)) != EqualTo)
  11457.     return result;
  11458.   if ((result = m_waitingList.Compare(other.m_waitingList)) != EqualTo)
  11459.     return result;
  11460.  
  11461.   return PASN_Sequence::Compare(other);
  11462. }
  11463.  
  11464.  
  11465. PINDEX GCC_ConductorPermissionGrantIndication::GetDataLength() const
  11466. {
  11467.   PINDEX length = 0;
  11468.   length += m_permissionList.GetObjectLength();
  11469.   if (HasOptionalField(e_waitingList))
  11470.     length += m_waitingList.GetObjectLength();
  11471.   return length;
  11472. }
  11473.  
  11474.  
  11475. BOOL GCC_ConductorPermissionGrantIndication::Decode(PASN_Stream & strm)
  11476. {
  11477.   if (!PreambleDecode(strm))
  11478.     return FALSE;
  11479.  
  11480.   if (!m_permissionList.Decode(strm))
  11481.     return FALSE;
  11482.   if (HasOptionalField(e_waitingList) && !m_waitingList.Decode(strm))
  11483.     return FALSE;
  11484.  
  11485.   return UnknownExtensionsDecode(strm);
  11486. }
  11487.  
  11488.  
  11489. void GCC_ConductorPermissionGrantIndication::Encode(PASN_Stream & strm) const
  11490. {
  11491.   PreambleEncode(strm);
  11492.  
  11493.   m_permissionList.Encode(strm);
  11494.   if (HasOptionalField(e_waitingList))
  11495.     m_waitingList.Encode(strm);
  11496.  
  11497.   UnknownExtensionsEncode(strm);
  11498. }
  11499.  
  11500.  
  11501. PObject * GCC_ConductorPermissionGrantIndication::Clone() const
  11502. {
  11503. #ifndef PASN_LEANANDMEAN
  11504.   PAssert(IsClass(GCC_ConductorPermissionGrantIndication::Class()), PInvalidCast);
  11505. #endif
  11506.   return new GCC_ConductorPermissionGrantIndication(*this);
  11507. }
  11508.  
  11509.  
  11510. //
  11511. // FunctionNotSupportedResponse
  11512. //
  11513.  
  11514. GCC_FunctionNotSupportedResponse::GCC_FunctionNotSupportedResponse(unsigned tag, PASN_Object::TagClass tagClass)
  11515.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  11516. {
  11517. }
  11518.  
  11519.  
  11520. #ifndef PASN_NOPRINTON
  11521. void GCC_FunctionNotSupportedResponse::PrintOn(ostream & strm) const
  11522. {
  11523.   int indent = strm.precision() + 2;
  11524.   strm << "{\n";
  11525.   strm << setw(indent+10) << "request = " << setprecision(indent) << m_request << '\n';
  11526.   strm << setw(indent-1) << "}";
  11527. }
  11528. #endif
  11529.  
  11530.  
  11531. PObject::Comparison GCC_FunctionNotSupportedResponse::Compare(const PObject & obj) const
  11532. {
  11533. #ifndef PASN_LEANANDMEAN
  11534.   PAssert(IsDescendant(GCC_FunctionNotSupportedResponse::Class()), PInvalidCast);
  11535. #endif
  11536.   const GCC_FunctionNotSupportedResponse & other = (const GCC_FunctionNotSupportedResponse &)obj;
  11537.  
  11538.   Comparison result;
  11539.  
  11540.   if ((result = m_request.Compare(other.m_request)) != EqualTo)
  11541.     return result;
  11542.  
  11543.   return PASN_Sequence::Compare(other);
  11544. }
  11545.  
  11546.  
  11547. PINDEX GCC_FunctionNotSupportedResponse::GetDataLength() const
  11548. {
  11549.   PINDEX length = 0;
  11550.   length += m_request.GetObjectLength();
  11551.   return length;
  11552. }
  11553.  
  11554.  
  11555. BOOL GCC_FunctionNotSupportedResponse::Decode(PASN_Stream & strm)
  11556. {
  11557.   if (!PreambleDecode(strm))
  11558.     return FALSE;
  11559.  
  11560.   if (!m_request.Decode(strm))
  11561.     return FALSE;
  11562.  
  11563.   return UnknownExtensionsDecode(strm);
  11564. }
  11565.  
  11566.  
  11567. void GCC_FunctionNotSupportedResponse::Encode(PASN_Stream & strm) const
  11568. {
  11569.   PreambleEncode(strm);
  11570.  
  11571.   m_request.Encode(strm);
  11572.  
  11573.   UnknownExtensionsEncode(strm);
  11574. }
  11575.  
  11576.  
  11577. PObject * GCC_FunctionNotSupportedResponse::Clone() const
  11578. {
  11579. #ifndef PASN_LEANANDMEAN
  11580.   PAssert(IsClass(GCC_FunctionNotSupportedResponse::Class()), PInvalidCast);
  11581. #endif
  11582.   return new GCC_FunctionNotSupportedResponse(*this);
  11583. }
  11584.  
  11585.  
  11586. //
  11587. // PasswordChallengeRequestResponse_challengeRequestResponse
  11588. //
  11589.  
  11590. GCC_PasswordChallengeRequestResponse_challengeRequestResponse::GCC_PasswordChallengeRequestResponse_challengeRequestResponse(unsigned tag, PASN_Object::TagClass tagClass)
  11591.   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
  11592. {
  11593. }
  11594.  
  11595.  
  11596. #ifndef PASN_NOPRINTON
  11597. void GCC_PasswordChallengeRequestResponse_challengeRequestResponse::PrintOn(ostream & strm) const
  11598. {
  11599.   int indent = strm.precision() + 2;
  11600.   strm << "{\n";
  11601.   if (HasOptionalField(e_challengeRequest))
  11602.     strm << setw(indent+19) << "challengeRequest = " << setprecision(indent) << m_challengeRequest << '\n';
  11603.   if (HasOptionalField(e_challengeResponse))
  11604.     strm << setw(indent+20) << "challengeResponse = " << setprecision(indent) << m_challengeResponse << '\n';
  11605.   strm << setw(indent-1) << "}";
  11606. }
  11607. #endif
  11608.  
  11609.  
  11610. PObject::Comparison GCC_PasswordChallengeRequestResponse_challengeRequestResponse::Compare(const PObject & obj) const
  11611. {
  11612. #ifndef PASN_LEANANDMEAN
  11613.   PAssert(IsDescendant(GCC_PasswordChallengeRequestResponse_challengeRequestResponse::Class()), PInvalidCast);
  11614. #endif
  11615.   const GCC_PasswordChallengeRequestResponse_challengeRequestResponse & other = (const GCC_PasswordChallengeRequestResponse_challengeRequestResponse &)obj;
  11616.  
  11617.   Comparison result;
  11618.  
  11619.   if ((result = m_challengeRequest.Compare(other.m_challengeRequest)) != EqualTo)
  11620.     return result;
  11621.   if ((result = m_challengeResponse.Compare(other.m_challengeResponse)) != EqualTo)
  11622.     return result;
  11623.  
  11624.   return PASN_Sequence::Compare(other);
  11625. }
  11626.  
  11627.  
  11628. PINDEX GCC_PasswordChallengeRequestResponse_challengeRequestResponse::GetDataLength() const
  11629. {
  11630.   PINDEX length = 0;
  11631.   if (HasOptionalField(e_challengeRequest))
  11632.     length += m_challengeRequest.GetObjectLength();
  11633.   if (HasOptionalField(e_challengeResponse))
  11634.     length += m_challengeResponse.GetObjectLength();
  11635.   return length;
  11636. }
  11637.  
  11638.  
  11639. BOOL GCC_PasswordChallengeRequestResponse_challengeRequestResponse::Decode(PASN_Stream & strm)
  11640. {
  11641.   if (!PreambleDecode(strm))
  11642.     return FALSE;
  11643.  
  11644.   if (HasOptionalField(e_challengeRequest) && !m_challengeRequest.Decode(strm))
  11645.     return FALSE;
  11646.   if (HasOptionalField(e_challengeResponse) && !m_challengeResponse.Decode(strm))
  11647.     return FALSE;
  11648.  
  11649.   return UnknownExtensionsDecode(strm);
  11650. }
  11651.  
  11652.  
  11653. void GCC_PasswordChallengeRequestResponse_challengeRequestResponse::Encode(PASN_Stream & strm) const
  11654. {
  11655.   PreambleEncode(strm);
  11656.  
  11657.   if (HasOptionalField(e_challengeRequest))
  11658.     m_challengeRequest.Encode(strm);
  11659.   if (HasOptionalField(e_challengeResponse))
  11660.     m_challengeResponse.Encode(strm);
  11661.  
  11662.   UnknownExtensionsEncode(strm);
  11663. }
  11664.  
  11665.  
  11666. PObject * GCC_PasswordChallengeRequestResponse_challengeRequestResponse::Clone() const
  11667. {
  11668. #ifndef PASN_LEANANDMEAN
  11669.   PAssert(IsClass(GCC_PasswordChallengeRequestResponse_challengeRequestResponse::Class()), PInvalidCast);
  11670. #endif
  11671.   return new GCC_PasswordChallengeRequestResponse_challengeRequestResponse(*this);
  11672. }
  11673.  
  11674.  
  11675. //
  11676. // RosterUpdateIndication_nodeInformation
  11677. //
  11678.  
  11679. GCC_RosterUpdateIndication_nodeInformation::GCC_RosterUpdateIndication_nodeInformation(unsigned tag, PASN_Object::TagClass tagClass)
  11680.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  11681. {
  11682.   m_rosterInstanceNumber.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  11683. }
  11684.  
  11685.  
  11686. #ifndef PASN_NOPRINTON
  11687. void GCC_RosterUpdateIndication_nodeInformation::PrintOn(ostream & strm) const
  11688. {
  11689.   int indent = strm.precision() + 2;
  11690.   strm << "{\n";
  11691.   strm << setw(indent+17) << "nodeRecordList = " << setprecision(indent) << m_nodeRecordList << '\n';
  11692.   strm << setw(indent+23) << "rosterInstanceNumber = " << setprecision(indent) << m_rosterInstanceNumber << '\n';
  11693.   strm << setw(indent+13) << "nodesAdded = " << setprecision(indent) << m_nodesAdded << '\n';
  11694.   strm << setw(indent+15) << "nodesRemoved = " << setprecision(indent) << m_nodesRemoved << '\n';
  11695.   strm << setw(indent-1) << "}";
  11696. }
  11697. #endif
  11698.  
  11699.  
  11700. PObject::Comparison GCC_RosterUpdateIndication_nodeInformation::Compare(const PObject & obj) const
  11701. {
  11702. #ifndef PASN_LEANANDMEAN
  11703.   PAssert(IsDescendant(GCC_RosterUpdateIndication_nodeInformation::Class()), PInvalidCast);
  11704. #endif
  11705.   const GCC_RosterUpdateIndication_nodeInformation & other = (const GCC_RosterUpdateIndication_nodeInformation &)obj;
  11706.  
  11707.   Comparison result;
  11708.  
  11709.   if ((result = m_nodeRecordList.Compare(other.m_nodeRecordList)) != EqualTo)
  11710.     return result;
  11711.   if ((result = m_rosterInstanceNumber.Compare(other.m_rosterInstanceNumber)) != EqualTo)
  11712.     return result;
  11713.   if ((result = m_nodesAdded.Compare(other.m_nodesAdded)) != EqualTo)
  11714.     return result;
  11715.   if ((result = m_nodesRemoved.Compare(other.m_nodesRemoved)) != EqualTo)
  11716.     return result;
  11717.  
  11718.   return PASN_Sequence::Compare(other);
  11719. }
  11720.  
  11721.  
  11722. PINDEX GCC_RosterUpdateIndication_nodeInformation::GetDataLength() const
  11723. {
  11724.   PINDEX length = 0;
  11725.   length += m_nodeRecordList.GetObjectLength();
  11726.   length += m_rosterInstanceNumber.GetObjectLength();
  11727.   length += m_nodesAdded.GetObjectLength();
  11728.   length += m_nodesRemoved.GetObjectLength();
  11729.   return length;
  11730. }
  11731.  
  11732.  
  11733. BOOL GCC_RosterUpdateIndication_nodeInformation::Decode(PASN_Stream & strm)
  11734. {
  11735.   if (!PreambleDecode(strm))
  11736.     return FALSE;
  11737.  
  11738.   if (!m_nodeRecordList.Decode(strm))
  11739.     return FALSE;
  11740.   if (!m_rosterInstanceNumber.Decode(strm))
  11741.     return FALSE;
  11742.   if (!m_nodesAdded.Decode(strm))
  11743.     return FALSE;
  11744.   if (!m_nodesRemoved.Decode(strm))
  11745.     return FALSE;
  11746.  
  11747.   return UnknownExtensionsDecode(strm);
  11748. }
  11749.  
  11750.  
  11751. void GCC_RosterUpdateIndication_nodeInformation::Encode(PASN_Stream & strm) const
  11752. {
  11753.   PreambleEncode(strm);
  11754.  
  11755.   m_nodeRecordList.Encode(strm);
  11756.   m_rosterInstanceNumber.Encode(strm);
  11757.   m_nodesAdded.Encode(strm);
  11758.   m_nodesRemoved.Encode(strm);
  11759.  
  11760.   UnknownExtensionsEncode(strm);
  11761. }
  11762.  
  11763.  
  11764. PObject * GCC_RosterUpdateIndication_nodeInformation::Clone() const
  11765. {
  11766. #ifndef PASN_LEANANDMEAN
  11767.   PAssert(IsClass(GCC_RosterUpdateIndication_nodeInformation::Class()), PInvalidCast);
  11768. #endif
  11769.   return new GCC_RosterUpdateIndication_nodeInformation(*this);
  11770. }
  11771.  
  11772.  
  11773. //
  11774. // NetworkAddress_subtype_aggregatedChannel
  11775. //
  11776.  
  11777. GCC_NetworkAddress_subtype_aggregatedChannel::GCC_NetworkAddress_subtype_aggregatedChannel(unsigned tag, PASN_Object::TagClass tagClass)
  11778.   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
  11779. {
  11780. }
  11781.  
  11782.  
  11783. #ifndef PASN_NOPRINTON
  11784. void GCC_NetworkAddress_subtype_aggregatedChannel::PrintOn(ostream & strm) const
  11785. {
  11786.   int indent = strm.precision() + 2;
  11787.   strm << "{\n";
  11788.   strm << setw(indent+16) << "transferModes = " << setprecision(indent) << m_transferModes << '\n';
  11789.   strm << setw(indent+22) << "internationalNumber = " << setprecision(indent) << m_internationalNumber << '\n';
  11790.   if (HasOptionalField(e_subAddress))
  11791.     strm << setw(indent+13) << "subAddress = " << setprecision(indent) << m_subAddress << '\n';
  11792.   if (HasOptionalField(e_extraDialing))
  11793.     strm << setw(indent+15) << "extraDialing = " << setprecision(indent) << m_extraDialing << '\n';
  11794.   if (HasOptionalField(e_highLayerCompatibility))
  11795.     strm << setw(indent+25) << "highLayerCompatibility = " << setprecision(indent) << m_highLayerCompatibility << '\n';
  11796.   strm << setw(indent-1) << "}";
  11797. }
  11798. #endif
  11799.  
  11800.  
  11801. PObject::Comparison GCC_NetworkAddress_subtype_aggregatedChannel::Compare(const PObject & obj) const
  11802. {
  11803. #ifndef PASN_LEANANDMEAN
  11804.   PAssert(IsDescendant(GCC_NetworkAddress_subtype_aggregatedChannel::Class()), PInvalidCast);
  11805. #endif
  11806.   const GCC_NetworkAddress_subtype_aggregatedChannel & other = (const GCC_NetworkAddress_subtype_aggregatedChannel &)obj;
  11807.  
  11808.   Comparison result;
  11809.  
  11810.   if ((result = m_transferModes.Compare(other.m_transferModes)) != EqualTo)
  11811.     return result;
  11812.   if ((result = m_internationalNumber.Compare(other.m_internationalNumber)) != EqualTo)
  11813.     return result;
  11814.   if ((result = m_subAddress.Compare(other.m_subAddress)) != EqualTo)
  11815.     return result;
  11816.   if ((result = m_extraDialing.Compare(other.m_extraDialing)) != EqualTo)
  11817.     return result;
  11818.   if ((result = m_highLayerCompatibility.Compare(other.m_highLayerCompatibility)) != EqualTo)
  11819.     return result;
  11820.  
  11821.   return PASN_Sequence::Compare(other);
  11822. }
  11823.  
  11824.  
  11825. PINDEX GCC_NetworkAddress_subtype_aggregatedChannel::GetDataLength() const
  11826. {
  11827.   PINDEX length = 0;
  11828.   length += m_transferModes.GetObjectLength();
  11829.   length += m_internationalNumber.GetObjectLength();
  11830.   if (HasOptionalField(e_subAddress))
  11831.     length += m_subAddress.GetObjectLength();
  11832.   if (HasOptionalField(e_extraDialing))
  11833.     length += m_extraDialing.GetObjectLength();
  11834.   if (HasOptionalField(e_highLayerCompatibility))
  11835.     length += m_highLayerCompatibility.GetObjectLength();
  11836.   return length;
  11837. }
  11838.  
  11839.  
  11840. BOOL GCC_NetworkAddress_subtype_aggregatedChannel::Decode(PASN_Stream & strm)
  11841. {
  11842.   if (!PreambleDecode(strm))
  11843.     return FALSE;
  11844.  
  11845.   if (!m_transferModes.Decode(strm))
  11846.     return FALSE;
  11847.   if (!m_internationalNumber.Decode(strm))
  11848.     return FALSE;
  11849.   if (HasOptionalField(e_subAddress) && !m_subAddress.Decode(strm))
  11850.     return FALSE;
  11851.   if (HasOptionalField(e_extraDialing) && !m_extraDialing.Decode(strm))
  11852.     return FALSE;
  11853.   if (HasOptionalField(e_highLayerCompatibility) && !m_highLayerCompatibility.Decode(strm))
  11854.     return FALSE;
  11855.  
  11856.   return UnknownExtensionsDecode(strm);
  11857. }
  11858.  
  11859.  
  11860. void GCC_NetworkAddress_subtype_aggregatedChannel::Encode(PASN_Stream & strm) const
  11861. {
  11862.   PreambleEncode(strm);
  11863.  
  11864.   m_transferModes.Encode(strm);
  11865.   m_internationalNumber.Encode(strm);
  11866.   if (HasOptionalField(e_subAddress))
  11867.     m_subAddress.Encode(strm);
  11868.   if (HasOptionalField(e_extraDialing))
  11869.     m_extraDialing.Encode(strm);
  11870.   if (HasOptionalField(e_highLayerCompatibility))
  11871.     m_highLayerCompatibility.Encode(strm);
  11872.  
  11873.   UnknownExtensionsEncode(strm);
  11874. }
  11875.  
  11876.  
  11877. PObject * GCC_NetworkAddress_subtype_aggregatedChannel::Clone() const
  11878. {
  11879. #ifndef PASN_LEANANDMEAN
  11880.   PAssert(IsClass(GCC_NetworkAddress_subtype_aggregatedChannel::Class()), PInvalidCast);
  11881. #endif
  11882.   return new GCC_NetworkAddress_subtype_aggregatedChannel(*this);
  11883. }
  11884.  
  11885.  
  11886. //
  11887. // RosterUpdateIndication_applicationInformation_subtype
  11888. //
  11889.  
  11890. GCC_RosterUpdateIndication_applicationInformation_subtype::GCC_RosterUpdateIndication_applicationInformation_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  11891.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  11892. {
  11893.   m_rosterInstanceNumber.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  11894. }
  11895.  
  11896.  
  11897. #ifndef PASN_NOPRINTON
  11898. void GCC_RosterUpdateIndication_applicationInformation_subtype::PrintOn(ostream & strm) const
  11899. {
  11900.   int indent = strm.precision() + 2;
  11901.   strm << "{\n";
  11902.   strm << setw(indent+13) << "sessionKey = " << setprecision(indent) << m_sessionKey << '\n';
  11903.   strm << setw(indent+24) << "applicationRecordList = " << setprecision(indent) << m_applicationRecordList << '\n';
  11904.   strm << setw(indent+30) << "applicationCapabilitiesList = " << setprecision(indent) << m_applicationCapabilitiesList << '\n';
  11905.   strm << setw(indent+23) << "rosterInstanceNumber = " << setprecision(indent) << m_rosterInstanceNumber << '\n';
  11906.   strm << setw(indent+20) << "peerEntitiesAdded = " << setprecision(indent) << m_peerEntitiesAdded << '\n';
  11907.   strm << setw(indent+22) << "peerEntitiesRemoved = " << setprecision(indent) << m_peerEntitiesRemoved << '\n';
  11908.   strm << setw(indent-1) << "}";
  11909. }
  11910. #endif
  11911.  
  11912.  
  11913. PObject::Comparison GCC_RosterUpdateIndication_applicationInformation_subtype::Compare(const PObject & obj) const
  11914. {
  11915. #ifndef PASN_LEANANDMEAN
  11916.   PAssert(IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype::Class()), PInvalidCast);
  11917. #endif
  11918.   const GCC_RosterUpdateIndication_applicationInformation_subtype & other = (const GCC_RosterUpdateIndication_applicationInformation_subtype &)obj;
  11919.  
  11920.   Comparison result;
  11921.  
  11922.   if ((result = m_sessionKey.Compare(other.m_sessionKey)) != EqualTo)
  11923.     return result;
  11924.   if ((result = m_applicationRecordList.Compare(other.m_applicationRecordList)) != EqualTo)
  11925.     return result;
  11926.   if ((result = m_applicationCapabilitiesList.Compare(other.m_applicationCapabilitiesList)) != EqualTo)
  11927.     return result;
  11928.   if ((result = m_rosterInstanceNumber.Compare(other.m_rosterInstanceNumber)) != EqualTo)
  11929.     return result;
  11930.   if ((result = m_peerEntitiesAdded.Compare(other.m_peerEntitiesAdded)) != EqualTo)
  11931.     return result;
  11932.   if ((result = m_peerEntitiesRemoved.Compare(other.m_peerEntitiesRemoved)) != EqualTo)
  11933.     return result;
  11934.  
  11935.   return PASN_Sequence::Compare(other);
  11936. }
  11937.  
  11938.  
  11939. PINDEX GCC_RosterUpdateIndication_applicationInformation_subtype::GetDataLength() const
  11940. {
  11941.   PINDEX length = 0;
  11942.   length += m_sessionKey.GetObjectLength();
  11943.   length += m_applicationRecordList.GetObjectLength();
  11944.   length += m_applicationCapabilitiesList.GetObjectLength();
  11945.   length += m_rosterInstanceNumber.GetObjectLength();
  11946.   length += m_peerEntitiesAdded.GetObjectLength();
  11947.   length += m_peerEntitiesRemoved.GetObjectLength();
  11948.   return length;
  11949. }
  11950.  
  11951.  
  11952. BOOL GCC_RosterUpdateIndication_applicationInformation_subtype::Decode(PASN_Stream & strm)
  11953. {
  11954.   if (!PreambleDecode(strm))
  11955.     return FALSE;
  11956.  
  11957.   if (!m_sessionKey.Decode(strm))
  11958.     return FALSE;
  11959.   if (!m_applicationRecordList.Decode(strm))
  11960.     return FALSE;
  11961.   if (!m_applicationCapabilitiesList.Decode(strm))
  11962.     return FALSE;
  11963.   if (!m_rosterInstanceNumber.Decode(strm))
  11964.     return FALSE;
  11965.   if (!m_peerEntitiesAdded.Decode(strm))
  11966.     return FALSE;
  11967.   if (!m_peerEntitiesRemoved.Decode(strm))
  11968.     return FALSE;
  11969.  
  11970.   return UnknownExtensionsDecode(strm);
  11971. }
  11972.  
  11973.  
  11974. void GCC_RosterUpdateIndication_applicationInformation_subtype::Encode(PASN_Stream & strm) const
  11975. {
  11976.   PreambleEncode(strm);
  11977.  
  11978.   m_sessionKey.Encode(strm);
  11979.   m_applicationRecordList.Encode(strm);
  11980.   m_applicationCapabilitiesList.Encode(strm);
  11981.   m_rosterInstanceNumber.Encode(strm);
  11982.   m_peerEntitiesAdded.Encode(strm);
  11983.   m_peerEntitiesRemoved.Encode(strm);
  11984.  
  11985.   UnknownExtensionsEncode(strm);
  11986. }
  11987.  
  11988.  
  11989. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype::Clone() const
  11990. {
  11991. #ifndef PASN_LEANANDMEAN
  11992.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype::Class()), PInvalidCast);
  11993. #endif
  11994.   return new GCC_RosterUpdateIndication_applicationInformation_subtype(*this);
  11995. }
  11996.  
  11997.  
  11998. //
  11999. // RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype
  12000. //
  12001.  
  12002. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype::GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  12003.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  12004. {
  12005. }
  12006.  
  12007.  
  12008. #ifndef PASN_NOPRINTON
  12009. void GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype::PrintOn(ostream & strm) const
  12010. {
  12011.   int indent = strm.precision() + 2;
  12012.   strm << "{\n";
  12013.   strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  12014.   strm << setw(indent+13) << "nodeRecord = " << setprecision(indent) << m_nodeRecord << '\n';
  12015.   strm << setw(indent-1) << "}";
  12016. }
  12017. #endif
  12018.  
  12019.  
  12020. PObject::Comparison GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype::Compare(const PObject & obj) const
  12021. {
  12022. #ifndef PASN_LEANANDMEAN
  12023.   PAssert(IsDescendant(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype::Class()), PInvalidCast);
  12024. #endif
  12025.   const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype & other = (const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype &)obj;
  12026.  
  12027.   Comparison result;
  12028.  
  12029.   if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
  12030.     return result;
  12031.   if ((result = m_nodeRecord.Compare(other.m_nodeRecord)) != EqualTo)
  12032.     return result;
  12033.  
  12034.   return PASN_Sequence::Compare(other);
  12035. }
  12036.  
  12037.  
  12038. PINDEX GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype::GetDataLength() const
  12039. {
  12040.   PINDEX length = 0;
  12041.   length += m_nodeID.GetObjectLength();
  12042.   length += m_nodeRecord.GetObjectLength();
  12043.   return length;
  12044. }
  12045.  
  12046.  
  12047. BOOL GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype::Decode(PASN_Stream & strm)
  12048. {
  12049.   if (!PreambleDecode(strm))
  12050.     return FALSE;
  12051.  
  12052.   if (!m_nodeID.Decode(strm))
  12053.     return FALSE;
  12054.   if (!m_nodeRecord.Decode(strm))
  12055.     return FALSE;
  12056.  
  12057.   return UnknownExtensionsDecode(strm);
  12058. }
  12059.  
  12060.  
  12061. void GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype::Encode(PASN_Stream & strm) const
  12062. {
  12063.   PreambleEncode(strm);
  12064.  
  12065.   m_nodeID.Encode(strm);
  12066.   m_nodeRecord.Encode(strm);
  12067.  
  12068.   UnknownExtensionsEncode(strm);
  12069. }
  12070.  
  12071.  
  12072. PObject * GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype::Clone() const
  12073. {
  12074. #ifndef PASN_LEANANDMEAN
  12075.   PAssert(IsClass(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype::Class()), PInvalidCast);
  12076. #endif
  12077.   return new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype(*this);
  12078. }
  12079.  
  12080.  
  12081. //
  12082. // RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype
  12083. //
  12084.  
  12085. GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype::GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  12086.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  12087. {
  12088. }
  12089.  
  12090.  
  12091. #ifndef PASN_NOPRINTON
  12092. void GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype::PrintOn(ostream & strm) const
  12093. {
  12094.   int indent = strm.precision() + 2;
  12095.   strm << "{\n";
  12096.   strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  12097.   strm << setw(indent+13) << "nodeUpdate = " << setprecision(indent) << m_nodeUpdate << '\n';
  12098.   strm << setw(indent-1) << "}";
  12099. }
  12100. #endif
  12101.  
  12102.  
  12103. PObject::Comparison GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype::Compare(const PObject & obj) const
  12104. {
  12105. #ifndef PASN_LEANANDMEAN
  12106.   PAssert(IsDescendant(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype::Class()), PInvalidCast);
  12107. #endif
  12108.   const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype & other = (const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype &)obj;
  12109.  
  12110.   Comparison result;
  12111.  
  12112.   if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
  12113.     return result;
  12114.   if ((result = m_nodeUpdate.Compare(other.m_nodeUpdate)) != EqualTo)
  12115.     return result;
  12116.  
  12117.   return PASN_Sequence::Compare(other);
  12118. }
  12119.  
  12120.  
  12121. PINDEX GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype::GetDataLength() const
  12122. {
  12123.   PINDEX length = 0;
  12124.   length += m_nodeID.GetObjectLength();
  12125.   length += m_nodeUpdate.GetObjectLength();
  12126.   return length;
  12127. }
  12128.  
  12129.  
  12130. BOOL GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype::Decode(PASN_Stream & strm)
  12131. {
  12132.   if (!PreambleDecode(strm))
  12133.     return FALSE;
  12134.  
  12135.   if (!m_nodeID.Decode(strm))
  12136.     return FALSE;
  12137.   if (!m_nodeUpdate.Decode(strm))
  12138.     return FALSE;
  12139.  
  12140.   return UnknownExtensionsDecode(strm);
  12141. }
  12142.  
  12143.  
  12144. void GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype::Encode(PASN_Stream & strm) const
  12145. {
  12146.   PreambleEncode(strm);
  12147.  
  12148.   m_nodeID.Encode(strm);
  12149.   m_nodeUpdate.Encode(strm);
  12150.  
  12151.   UnknownExtensionsEncode(strm);
  12152. }
  12153.  
  12154.  
  12155. PObject * GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype::Clone() const
  12156. {
  12157. #ifndef PASN_LEANANDMEAN
  12158.   PAssert(IsClass(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype::Class()), PInvalidCast);
  12159. #endif
  12160.   return new GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype(*this);
  12161. }
  12162.  
  12163.  
  12164. //
  12165. // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype
  12166. //
  12167.  
  12168. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype::GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  12169.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  12170. {
  12171. }
  12172.  
  12173.  
  12174. #ifndef PASN_NOPRINTON
  12175. void GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype::PrintOn(ostream & strm) const
  12176. {
  12177.   int indent = strm.precision() + 2;
  12178.   strm << "{\n";
  12179.   strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  12180.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  12181.   strm << setw(indent+20) << "applicationRecord = " << setprecision(indent) << m_applicationRecord << '\n';
  12182.   strm << setw(indent-1) << "}";
  12183. }
  12184. #endif
  12185.  
  12186.  
  12187. PObject::Comparison GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype::Compare(const PObject & obj) const
  12188. {
  12189. #ifndef PASN_LEANANDMEAN
  12190.   PAssert(IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype::Class()), PInvalidCast);
  12191. #endif
  12192.   const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype & other = (const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype &)obj;
  12193.  
  12194.   Comparison result;
  12195.  
  12196.   if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
  12197.     return result;
  12198.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  12199.     return result;
  12200.   if ((result = m_applicationRecord.Compare(other.m_applicationRecord)) != EqualTo)
  12201.     return result;
  12202.  
  12203.   return PASN_Sequence::Compare(other);
  12204. }
  12205.  
  12206.  
  12207. PINDEX GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype::GetDataLength() const
  12208. {
  12209.   PINDEX length = 0;
  12210.   length += m_nodeID.GetObjectLength();
  12211.   length += m_entityID.GetObjectLength();
  12212.   length += m_applicationRecord.GetObjectLength();
  12213.   return length;
  12214. }
  12215.  
  12216.  
  12217. BOOL GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype::Decode(PASN_Stream & strm)
  12218. {
  12219.   if (!PreambleDecode(strm))
  12220.     return FALSE;
  12221.  
  12222.   if (!m_nodeID.Decode(strm))
  12223.     return FALSE;
  12224.   if (!m_entityID.Decode(strm))
  12225.     return FALSE;
  12226.   if (!m_applicationRecord.Decode(strm))
  12227.     return FALSE;
  12228.  
  12229.   return UnknownExtensionsDecode(strm);
  12230. }
  12231.  
  12232.  
  12233. void GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype::Encode(PASN_Stream & strm) const
  12234. {
  12235.   PreambleEncode(strm);
  12236.  
  12237.   m_nodeID.Encode(strm);
  12238.   m_entityID.Encode(strm);
  12239.   m_applicationRecord.Encode(strm);
  12240.  
  12241.   UnknownExtensionsEncode(strm);
  12242. }
  12243.  
  12244.  
  12245. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype::Clone() const
  12246. {
  12247. #ifndef PASN_LEANANDMEAN
  12248.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype::Class()), PInvalidCast);
  12249. #endif
  12250.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype(*this);
  12251. }
  12252.  
  12253.  
  12254. //
  12255. // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype
  12256. //
  12257.  
  12258. GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype::GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype(unsigned tag, PASN_Object::TagClass tagClass)
  12259.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  12260. {
  12261. }
  12262.  
  12263.  
  12264. #ifndef PASN_NOPRINTON
  12265. void GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype::PrintOn(ostream & strm) const
  12266. {
  12267.   int indent = strm.precision() + 2;
  12268.   strm << "{\n";
  12269.   strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  12270.   strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  12271.   strm << setw(indent+20) << "applicationUpdate = " << setprecision(indent) << m_applicationUpdate << '\n';
  12272.   strm << setw(indent-1) << "}";
  12273. }
  12274. #endif
  12275.  
  12276.  
  12277. PObject::Comparison GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype::Compare(const PObject & obj) const
  12278. {
  12279. #ifndef PASN_LEANANDMEAN
  12280.   PAssert(IsDescendant(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype::Class()), PInvalidCast);
  12281. #endif
  12282.   const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype & other = (const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype &)obj;
  12283.  
  12284.   Comparison result;
  12285.  
  12286.   if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
  12287.     return result;
  12288.   if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
  12289.     return result;
  12290.   if ((result = m_applicationUpdate.Compare(other.m_applicationUpdate)) != EqualTo)
  12291.     return result;
  12292.  
  12293.   return PASN_Sequence::Compare(other);
  12294. }
  12295.  
  12296.  
  12297. PINDEX GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype::GetDataLength() const
  12298. {
  12299.   PINDEX length = 0;
  12300.   length += m_nodeID.GetObjectLength();
  12301.   length += m_entityID.GetObjectLength();
  12302.   length += m_applicationUpdate.GetObjectLength();
  12303.   return length;
  12304. }
  12305.  
  12306.  
  12307. BOOL GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype::Decode(PASN_Stream & strm)
  12308. {
  12309.   if (!PreambleDecode(strm))
  12310.     return FALSE;
  12311.  
  12312.   if (!m_nodeID.Decode(strm))
  12313.     return FALSE;
  12314.   if (!m_entityID.Decode(strm))
  12315.     return FALSE;
  12316.   if (!m_applicationUpdate.Decode(strm))
  12317.     return FALSE;
  12318.  
  12319.   return UnknownExtensionsDecode(strm);
  12320. }
  12321.  
  12322.  
  12323. void GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype::Encode(PASN_Stream & strm) const
  12324. {
  12325.   PreambleEncode(strm);
  12326.  
  12327.   m_nodeID.Encode(strm);
  12328.   m_entityID.Encode(strm);
  12329.   m_applicationUpdate.Encode(strm);
  12330.  
  12331.   UnknownExtensionsEncode(strm);
  12332. }
  12333.  
  12334.  
  12335. PObject * GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype::Clone() const
  12336. {
  12337. #ifndef PASN_LEANANDMEAN
  12338.   PAssert(IsClass(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype::Class()), PInvalidCast);
  12339. #endif
  12340.   return new GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype(*this);
  12341. }
  12342.  
  12343.  
  12344. //
  12345. // RosterUpdateIndication
  12346. //
  12347.  
  12348. GCC_RosterUpdateIndication::GCC_RosterUpdateIndication(unsigned tag, PASN_Object::TagClass tagClass)
  12349.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  12350. {
  12351. }
  12352.  
  12353.  
  12354. #ifndef PASN_NOPRINTON
  12355. void GCC_RosterUpdateIndication::PrintOn(ostream & strm) const
  12356. {
  12357.   int indent = strm.precision() + 2;
  12358.   strm << "{\n";
  12359.   strm << setw(indent+14) << "fullRefresh = " << setprecision(indent) << m_fullRefresh << '\n';
  12360.   strm << setw(indent+18) << "nodeInformation = " << setprecision(indent) << m_nodeInformation << '\n';
  12361.   strm << setw(indent+25) << "applicationInformation = " << setprecision(indent) << m_applicationInformation << '\n';
  12362.   strm << setw(indent-1) << "}";
  12363. }
  12364. #endif
  12365.  
  12366.  
  12367. PObject::Comparison GCC_RosterUpdateIndication::Compare(const PObject & obj) const
  12368. {
  12369. #ifndef PASN_LEANANDMEAN
  12370.   PAssert(IsDescendant(GCC_RosterUpdateIndication::Class()), PInvalidCast);
  12371. #endif
  12372.   const GCC_RosterUpdateIndication & other = (const GCC_RosterUpdateIndication &)obj;
  12373.  
  12374.   Comparison result;
  12375.  
  12376.   if ((result = m_fullRefresh.Compare(other.m_fullRefresh)) != EqualTo)
  12377.     return result;
  12378.   if ((result = m_nodeInformation.Compare(other.m_nodeInformation)) != EqualTo)
  12379.     return result;
  12380.   if ((result = m_applicationInformation.Compare(other.m_applicationInformation)) != EqualTo)
  12381.     return result;
  12382.  
  12383.   return PASN_Sequence::Compare(other);
  12384. }
  12385.  
  12386.  
  12387. PINDEX GCC_RosterUpdateIndication::GetDataLength() const
  12388. {
  12389.   PINDEX length = 0;
  12390.   length += m_fullRefresh.GetObjectLength();
  12391.   length += m_nodeInformation.GetObjectLength();
  12392.   length += m_applicationInformation.GetObjectLength();
  12393.   return length;
  12394. }
  12395.  
  12396.  
  12397. BOOL GCC_RosterUpdateIndication::Decode(PASN_Stream & strm)
  12398. {
  12399.   if (!PreambleDecode(strm))
  12400.     return FALSE;
  12401.  
  12402.   if (!m_fullRefresh.Decode(strm))
  12403.     return FALSE;
  12404.   if (!m_nodeInformation.Decode(strm))
  12405.     return FALSE;
  12406.   if (!m_applicationInformation.Decode(strm))
  12407.     return FALSE;
  12408.  
  12409.   return UnknownExtensionsDecode(strm);
  12410. }
  12411.  
  12412.  
  12413. void GCC_RosterUpdateIndication::Encode(PASN_Stream & strm) const
  12414. {
  12415.   PreambleEncode(strm);
  12416.  
  12417.   m_fullRefresh.Encode(strm);
  12418.   m_nodeInformation.Encode(strm);
  12419.   m_applicationInformation.Encode(strm);
  12420.  
  12421.   UnknownExtensionsEncode(strm);
  12422. }
  12423.  
  12424.  
  12425. PObject * GCC_RosterUpdateIndication::Clone() const
  12426. {
  12427. #ifndef PASN_LEANANDMEAN
  12428.   PAssert(IsClass(GCC_RosterUpdateIndication::Class()), PInvalidCast);
  12429. #endif
  12430.   return new GCC_RosterUpdateIndication(*this);
  12431. }
  12432.  
  12433.  
  12434. #endif // if ! H323_DISABLE_GCC
  12435.  
  12436.  
  12437. // End of gccpdu.cxx
  12438.