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 / x880.cxx < prev   
C/C++ Source or Header  |  2004-06-22  |  21KB  |  982 lines
  1. //
  2. // x880.cxx
  3. //
  4. // Code automatically generated by asnparse.
  5. //
  6.  
  7. #ifdef __GNUC__
  8. #pragma implementation "x880.h"
  9. #endif
  10.  
  11. #include <ptlib.h>
  12. #include "x880.h"
  13.  
  14. #define new PNEW
  15.  
  16.  
  17. #if ! H323_DISABLE_X880
  18.  
  19. //
  20. // ROS
  21. //
  22.  
  23. X880_ROS::X880_ROS(unsigned tag, PASN_Object::TagClass tagClass)
  24.   : PASN_Choice(tag, tagClass, 4, FALSE
  25. #ifndef PASN_NOPRINTON
  26.       , "invoke "
  27.         "returnResult "
  28.         "returnError "
  29.         "reject "
  30. #endif
  31.     )
  32. {
  33. }
  34.  
  35.  
  36. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  37. X880_ROS::operator X880_Invoke &() const
  38. #else
  39. X880_ROS::operator X880_Invoke &()
  40. {
  41. #ifndef PASN_LEANANDMEAN
  42.   PAssert(PAssertNULL(choice)->IsDescendant(X880_Invoke::Class()), PInvalidCast);
  43. #endif
  44.   return *(X880_Invoke *)choice;
  45. }
  46.  
  47.  
  48. X880_ROS::operator const X880_Invoke &() const
  49. #endif
  50. {
  51. #ifndef PASN_LEANANDMEAN
  52.   PAssert(PAssertNULL(choice)->IsDescendant(X880_Invoke::Class()), PInvalidCast);
  53. #endif
  54.   return *(X880_Invoke *)choice;
  55. }
  56.  
  57.  
  58. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  59. X880_ROS::operator X880_ReturnResult &() const
  60. #else
  61. X880_ROS::operator X880_ReturnResult &()
  62. {
  63. #ifndef PASN_LEANANDMEAN
  64.   PAssert(PAssertNULL(choice)->IsDescendant(X880_ReturnResult::Class()), PInvalidCast);
  65. #endif
  66.   return *(X880_ReturnResult *)choice;
  67. }
  68.  
  69.  
  70. X880_ROS::operator const X880_ReturnResult &() const
  71. #endif
  72. {
  73. #ifndef PASN_LEANANDMEAN
  74.   PAssert(PAssertNULL(choice)->IsDescendant(X880_ReturnResult::Class()), PInvalidCast);
  75. #endif
  76.   return *(X880_ReturnResult *)choice;
  77. }
  78.  
  79.  
  80. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  81. X880_ROS::operator X880_ReturnError &() const
  82. #else
  83. X880_ROS::operator X880_ReturnError &()
  84. {
  85. #ifndef PASN_LEANANDMEAN
  86.   PAssert(PAssertNULL(choice)->IsDescendant(X880_ReturnError::Class()), PInvalidCast);
  87. #endif
  88.   return *(X880_ReturnError *)choice;
  89. }
  90.  
  91.  
  92. X880_ROS::operator const X880_ReturnError &() const
  93. #endif
  94. {
  95. #ifndef PASN_LEANANDMEAN
  96.   PAssert(PAssertNULL(choice)->IsDescendant(X880_ReturnError::Class()), PInvalidCast);
  97. #endif
  98.   return *(X880_ReturnError *)choice;
  99. }
  100.  
  101.  
  102. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  103. X880_ROS::operator X880_Reject &() const
  104. #else
  105. X880_ROS::operator X880_Reject &()
  106. {
  107. #ifndef PASN_LEANANDMEAN
  108.   PAssert(PAssertNULL(choice)->IsDescendant(X880_Reject::Class()), PInvalidCast);
  109. #endif
  110.   return *(X880_Reject *)choice;
  111. }
  112.  
  113.  
  114. X880_ROS::operator const X880_Reject &() const
  115. #endif
  116. {
  117. #ifndef PASN_LEANANDMEAN
  118.   PAssert(PAssertNULL(choice)->IsDescendant(X880_Reject::Class()), PInvalidCast);
  119. #endif
  120.   return *(X880_Reject *)choice;
  121. }
  122.  
  123.  
  124. BOOL X880_ROS::CreateObject()
  125. {
  126.   switch (tag) {
  127.     case e_invoke :
  128.       choice = new X880_Invoke(1, ContextSpecificTagClass);
  129.       return TRUE;
  130.     case e_returnResult :
  131.       choice = new X880_ReturnResult(2, ContextSpecificTagClass);
  132.       return TRUE;
  133.     case e_returnError :
  134.       choice = new X880_ReturnError(3, ContextSpecificTagClass);
  135.       return TRUE;
  136.     case e_reject :
  137.       choice = new X880_Reject(4, ContextSpecificTagClass);
  138.       return TRUE;
  139.   }
  140.  
  141.   choice = NULL;
  142.   return FALSE;
  143. }
  144.  
  145.  
  146. PObject * X880_ROS::Clone() const
  147. {
  148. #ifndef PASN_LEANANDMEAN
  149.   PAssert(IsClass(X880_ROS::Class()), PInvalidCast);
  150. #endif
  151.   return new X880_ROS(*this);
  152. }
  153.  
  154.  
  155. //
  156. // GeneralProblem
  157. //
  158.  
  159. X880_GeneralProblem::X880_GeneralProblem(unsigned tag, PASN_Object::TagClass tagClass)
  160.   : PASN_Integer(tag, tagClass)
  161. {
  162. }
  163.  
  164.  
  165. X880_GeneralProblem & X880_GeneralProblem::operator=(int v)
  166. {
  167.   SetValue(v);
  168.   return *this;
  169. }
  170.  
  171.  
  172. X880_GeneralProblem & X880_GeneralProblem::operator=(unsigned v)
  173. {
  174.   SetValue(v);
  175.   return *this;
  176. }
  177.  
  178.  
  179. PObject * X880_GeneralProblem::Clone() const
  180. {
  181. #ifndef PASN_LEANANDMEAN
  182.   PAssert(IsClass(X880_GeneralProblem::Class()), PInvalidCast);
  183. #endif
  184.   return new X880_GeneralProblem(*this);
  185. }
  186.  
  187.  
  188. //
  189. // InvokeProblem
  190. //
  191.  
  192. X880_InvokeProblem::X880_InvokeProblem(unsigned tag, PASN_Object::TagClass tagClass)
  193.   : PASN_Integer(tag, tagClass)
  194. {
  195. }
  196.  
  197.  
  198. X880_InvokeProblem & X880_InvokeProblem::operator=(int v)
  199. {
  200.   SetValue(v);
  201.   return *this;
  202. }
  203.  
  204.  
  205. X880_InvokeProblem & X880_InvokeProblem::operator=(unsigned v)
  206. {
  207.   SetValue(v);
  208.   return *this;
  209. }
  210.  
  211.  
  212. PObject * X880_InvokeProblem::Clone() const
  213. {
  214. #ifndef PASN_LEANANDMEAN
  215.   PAssert(IsClass(X880_InvokeProblem::Class()), PInvalidCast);
  216. #endif
  217.   return new X880_InvokeProblem(*this);
  218. }
  219.  
  220.  
  221. //
  222. // ReturnResultProblem
  223. //
  224.  
  225. X880_ReturnResultProblem::X880_ReturnResultProblem(unsigned tag, PASN_Object::TagClass tagClass)
  226.   : PASN_Integer(tag, tagClass)
  227. {
  228. }
  229.  
  230.  
  231. X880_ReturnResultProblem & X880_ReturnResultProblem::operator=(int v)
  232. {
  233.   SetValue(v);
  234.   return *this;
  235. }
  236.  
  237.  
  238. X880_ReturnResultProblem & X880_ReturnResultProblem::operator=(unsigned v)
  239. {
  240.   SetValue(v);
  241.   return *this;
  242. }
  243.  
  244.  
  245. PObject * X880_ReturnResultProblem::Clone() const
  246. {
  247. #ifndef PASN_LEANANDMEAN
  248.   PAssert(IsClass(X880_ReturnResultProblem::Class()), PInvalidCast);
  249. #endif
  250.   return new X880_ReturnResultProblem(*this);
  251. }
  252.  
  253.  
  254. //
  255. // ReturnErrorProblem
  256. //
  257.  
  258. X880_ReturnErrorProblem::X880_ReturnErrorProblem(unsigned tag, PASN_Object::TagClass tagClass)
  259.   : PASN_Integer(tag, tagClass)
  260. {
  261. }
  262.  
  263.  
  264. X880_ReturnErrorProblem & X880_ReturnErrorProblem::operator=(int v)
  265. {
  266.   SetValue(v);
  267.   return *this;
  268. }
  269.  
  270.  
  271. X880_ReturnErrorProblem & X880_ReturnErrorProblem::operator=(unsigned v)
  272. {
  273.   SetValue(v);
  274.   return *this;
  275. }
  276.  
  277.  
  278. PObject * X880_ReturnErrorProblem::Clone() const
  279. {
  280. #ifndef PASN_LEANANDMEAN
  281.   PAssert(IsClass(X880_ReturnErrorProblem::Class()), PInvalidCast);
  282. #endif
  283.   return new X880_ReturnErrorProblem(*this);
  284. }
  285.  
  286.  
  287. //
  288. // RejectProblem
  289. //
  290.  
  291. X880_RejectProblem::X880_RejectProblem(unsigned tag, PASN_Object::TagClass tagClass)
  292.   : PASN_Integer(tag, tagClass)
  293. {
  294. }
  295.  
  296.  
  297. X880_RejectProblem & X880_RejectProblem::operator=(int v)
  298. {
  299.   SetValue(v);
  300.   return *this;
  301. }
  302.  
  303.  
  304. X880_RejectProblem & X880_RejectProblem::operator=(unsigned v)
  305. {
  306.   SetValue(v);
  307.   return *this;
  308. }
  309.  
  310.  
  311. PObject * X880_RejectProblem::Clone() const
  312. {
  313. #ifndef PASN_LEANANDMEAN
  314.   PAssert(IsClass(X880_RejectProblem::Class()), PInvalidCast);
  315. #endif
  316.   return new X880_RejectProblem(*this);
  317. }
  318.  
  319.  
  320. //
  321. // InvokeId
  322. //
  323.  
  324. X880_InvokeId::X880_InvokeId(unsigned tag, PASN_Object::TagClass tagClass)
  325.   : PASN_Integer(tag, tagClass)
  326. {
  327. }
  328.  
  329.  
  330. X880_InvokeId & X880_InvokeId::operator=(int v)
  331. {
  332.   SetValue(v);
  333.   return *this;
  334. }
  335.  
  336.  
  337. X880_InvokeId & X880_InvokeId::operator=(unsigned v)
  338. {
  339.   SetValue(v);
  340.   return *this;
  341. }
  342.  
  343.  
  344. PObject * X880_InvokeId::Clone() const
  345. {
  346. #ifndef PASN_LEANANDMEAN
  347.   PAssert(IsClass(X880_InvokeId::Class()), PInvalidCast);
  348. #endif
  349.   return new X880_InvokeId(*this);
  350. }
  351.  
  352.  
  353. //
  354. // Code
  355. //
  356.  
  357. X880_Code::X880_Code(unsigned tag, PASN_Object::TagClass tagClass)
  358.   : PASN_Choice(tag, tagClass, 2, FALSE
  359. #ifndef PASN_NOPRINTON
  360.       , "local "
  361.         "global "
  362. #endif
  363.     )
  364. {
  365. }
  366.  
  367.  
  368. BOOL X880_Code::CreateObject()
  369. {
  370.   switch (tag) {
  371.     case e_local :
  372.       choice = new PASN_Integer();
  373.       return TRUE;
  374.     case e_global :
  375.       choice = new PASN_ObjectId();
  376.       return TRUE;
  377.   }
  378.  
  379.   choice = NULL;
  380.   return FALSE;
  381. }
  382.  
  383.  
  384. PObject * X880_Code::Clone() const
  385. {
  386. #ifndef PASN_LEANANDMEAN
  387.   PAssert(IsClass(X880_Code::Class()), PInvalidCast);
  388. #endif
  389.   return new X880_Code(*this);
  390. }
  391.  
  392.  
  393. //
  394. // ReturnResult_result
  395. //
  396.  
  397. X880_ReturnResult_result::X880_ReturnResult_result(unsigned tag, PASN_Object::TagClass tagClass)
  398.   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
  399. {
  400. }
  401.  
  402.  
  403. #ifndef PASN_NOPRINTON
  404. void X880_ReturnResult_result::PrintOn(ostream & strm) const
  405. {
  406.   int indent = strm.precision() + 2;
  407.   strm << "{\n";
  408.   strm << setw(indent+9) << "opcode = " << setprecision(indent) << m_opcode << '\n';
  409.   strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  410.   strm << setw(indent-1) << "}";
  411. }
  412. #endif
  413.  
  414.  
  415. PObject::Comparison X880_ReturnResult_result::Compare(const PObject & obj) const
  416. {
  417. #ifndef PASN_LEANANDMEAN
  418.   PAssert(IsDescendant(X880_ReturnResult_result::Class()), PInvalidCast);
  419. #endif
  420.   const X880_ReturnResult_result & other = (const X880_ReturnResult_result &)obj;
  421.  
  422.   Comparison result;
  423.  
  424.   if ((result = m_opcode.Compare(other.m_opcode)) != EqualTo)
  425.     return result;
  426.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  427.     return result;
  428.  
  429.   return PASN_Sequence::Compare(other);
  430. }
  431.  
  432.  
  433. PINDEX X880_ReturnResult_result::GetDataLength() const
  434. {
  435.   PINDEX length = 0;
  436.   length += m_opcode.GetObjectLength();
  437.   length += m_result.GetObjectLength();
  438.   return length;
  439. }
  440.  
  441.  
  442. BOOL X880_ReturnResult_result::Decode(PASN_Stream & strm)
  443. {
  444.   if (!PreambleDecode(strm))
  445.     return FALSE;
  446.  
  447.   if (!m_opcode.Decode(strm))
  448.     return FALSE;
  449.   if (!m_result.Decode(strm))
  450.     return FALSE;
  451.  
  452.   return UnknownExtensionsDecode(strm);
  453. }
  454.  
  455.  
  456. void X880_ReturnResult_result::Encode(PASN_Stream & strm) const
  457. {
  458.   PreambleEncode(strm);
  459.  
  460.   m_opcode.Encode(strm);
  461.   m_result.Encode(strm);
  462.  
  463.   UnknownExtensionsEncode(strm);
  464. }
  465.  
  466.  
  467. PObject * X880_ReturnResult_result::Clone() const
  468. {
  469. #ifndef PASN_LEANANDMEAN
  470.   PAssert(IsClass(X880_ReturnResult_result::Class()), PInvalidCast);
  471. #endif
  472.   return new X880_ReturnResult_result(*this);
  473. }
  474.  
  475.  
  476. //
  477. // Reject_problem
  478. //
  479.  
  480. X880_Reject_problem::X880_Reject_problem(unsigned tag, PASN_Object::TagClass tagClass)
  481.   : PASN_Choice(tag, tagClass, 4, FALSE
  482. #ifndef PASN_NOPRINTON
  483.       , "general "
  484.         "invoke "
  485.         "returnResult "
  486.         "returnError "
  487. #endif
  488.     )
  489. {
  490. }
  491.  
  492.  
  493. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  494. X880_Reject_problem::operator X880_GeneralProblem &() const
  495. #else
  496. X880_Reject_problem::operator X880_GeneralProblem &()
  497. {
  498. #ifndef PASN_LEANANDMEAN
  499.   PAssert(PAssertNULL(choice)->IsDescendant(X880_GeneralProblem::Class()), PInvalidCast);
  500. #endif
  501.   return *(X880_GeneralProblem *)choice;
  502. }
  503.  
  504.  
  505. X880_Reject_problem::operator const X880_GeneralProblem &() const
  506. #endif
  507. {
  508. #ifndef PASN_LEANANDMEAN
  509.   PAssert(PAssertNULL(choice)->IsDescendant(X880_GeneralProblem::Class()), PInvalidCast);
  510. #endif
  511.   return *(X880_GeneralProblem *)choice;
  512. }
  513.  
  514.  
  515. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  516. X880_Reject_problem::operator X880_InvokeProblem &() const
  517. #else
  518. X880_Reject_problem::operator X880_InvokeProblem &()
  519. {
  520. #ifndef PASN_LEANANDMEAN
  521.   PAssert(PAssertNULL(choice)->IsDescendant(X880_InvokeProblem::Class()), PInvalidCast);
  522. #endif
  523.   return *(X880_InvokeProblem *)choice;
  524. }
  525.  
  526.  
  527. X880_Reject_problem::operator const X880_InvokeProblem &() const
  528. #endif
  529. {
  530. #ifndef PASN_LEANANDMEAN
  531.   PAssert(PAssertNULL(choice)->IsDescendant(X880_InvokeProblem::Class()), PInvalidCast);
  532. #endif
  533.   return *(X880_InvokeProblem *)choice;
  534. }
  535.  
  536.  
  537. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  538. X880_Reject_problem::operator X880_ReturnResultProblem &() const
  539. #else
  540. X880_Reject_problem::operator X880_ReturnResultProblem &()
  541. {
  542. #ifndef PASN_LEANANDMEAN
  543.   PAssert(PAssertNULL(choice)->IsDescendant(X880_ReturnResultProblem::Class()), PInvalidCast);
  544. #endif
  545.   return *(X880_ReturnResultProblem *)choice;
  546. }
  547.  
  548.  
  549. X880_Reject_problem::operator const X880_ReturnResultProblem &() const
  550. #endif
  551. {
  552. #ifndef PASN_LEANANDMEAN
  553.   PAssert(PAssertNULL(choice)->IsDescendant(X880_ReturnResultProblem::Class()), PInvalidCast);
  554. #endif
  555.   return *(X880_ReturnResultProblem *)choice;
  556. }
  557.  
  558.  
  559. #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
  560. X880_Reject_problem::operator X880_ReturnErrorProblem &() const
  561. #else
  562. X880_Reject_problem::operator X880_ReturnErrorProblem &()
  563. {
  564. #ifndef PASN_LEANANDMEAN
  565.   PAssert(PAssertNULL(choice)->IsDescendant(X880_ReturnErrorProblem::Class()), PInvalidCast);
  566. #endif
  567.   return *(X880_ReturnErrorProblem *)choice;
  568. }
  569.  
  570.  
  571. X880_Reject_problem::operator const X880_ReturnErrorProblem &() const
  572. #endif
  573. {
  574. #ifndef PASN_LEANANDMEAN
  575.   PAssert(PAssertNULL(choice)->IsDescendant(X880_ReturnErrorProblem::Class()), PInvalidCast);
  576. #endif
  577.   return *(X880_ReturnErrorProblem *)choice;
  578. }
  579.  
  580.  
  581. BOOL X880_Reject_problem::CreateObject()
  582. {
  583.   switch (tag) {
  584.     case e_general :
  585.       choice = new X880_GeneralProblem();
  586.       return TRUE;
  587.     case e_invoke :
  588.       choice = new X880_InvokeProblem();
  589.       return TRUE;
  590.     case e_returnResult :
  591.       choice = new X880_ReturnResultProblem();
  592.       return TRUE;
  593.     case e_returnError :
  594.       choice = new X880_ReturnErrorProblem();
  595.       return TRUE;
  596.   }
  597.  
  598.   choice = NULL;
  599.   return FALSE;
  600. }
  601.  
  602.  
  603. PObject * X880_Reject_problem::Clone() const
  604. {
  605. #ifndef PASN_LEANANDMEAN
  606.   PAssert(IsClass(X880_Reject_problem::Class()), PInvalidCast);
  607. #endif
  608.   return new X880_Reject_problem(*this);
  609. }
  610.  
  611.  
  612. //
  613. // Invoke
  614. //
  615.  
  616. X880_Invoke::X880_Invoke(unsigned tag, PASN_Object::TagClass tagClass)
  617.   : PASN_Sequence(tag, tagClass, 2, FALSE, 0)
  618. {
  619.   m_invokeId.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
  620. }
  621.  
  622.  
  623. #ifndef PASN_NOPRINTON
  624. void X880_Invoke::PrintOn(ostream & strm) const
  625. {
  626.   int indent = strm.precision() + 2;
  627.   strm << "{\n";
  628.   strm << setw(indent+11) << "invokeId = " << setprecision(indent) << m_invokeId << '\n';
  629.   if (HasOptionalField(e_linkedId))
  630.     strm << setw(indent+11) << "linkedId = " << setprecision(indent) << m_linkedId << '\n';
  631.   strm << setw(indent+9) << "opcode = " << setprecision(indent) << m_opcode << '\n';
  632.   if (HasOptionalField(e_argument))
  633.     strm << setw(indent+11) << "argument = " << setprecision(indent) << m_argument << '\n';
  634.   strm << setw(indent-1) << "}";
  635. }
  636. #endif
  637.  
  638.  
  639. PObject::Comparison X880_Invoke::Compare(const PObject & obj) const
  640. {
  641. #ifndef PASN_LEANANDMEAN
  642.   PAssert(IsDescendant(X880_Invoke::Class()), PInvalidCast);
  643. #endif
  644.   const X880_Invoke & other = (const X880_Invoke &)obj;
  645.  
  646.   Comparison result;
  647.  
  648.   if ((result = m_invokeId.Compare(other.m_invokeId)) != EqualTo)
  649.     return result;
  650.   if ((result = m_linkedId.Compare(other.m_linkedId)) != EqualTo)
  651.     return result;
  652.   if ((result = m_opcode.Compare(other.m_opcode)) != EqualTo)
  653.     return result;
  654.   if ((result = m_argument.Compare(other.m_argument)) != EqualTo)
  655.     return result;
  656.  
  657.   return PASN_Sequence::Compare(other);
  658. }
  659.  
  660.  
  661. PINDEX X880_Invoke::GetDataLength() const
  662. {
  663.   PINDEX length = 0;
  664.   length += m_invokeId.GetObjectLength();
  665.   if (HasOptionalField(e_linkedId))
  666.     length += m_linkedId.GetObjectLength();
  667.   length += m_opcode.GetObjectLength();
  668.   if (HasOptionalField(e_argument))
  669.     length += m_argument.GetObjectLength();
  670.   return length;
  671. }
  672.  
  673.  
  674. BOOL X880_Invoke::Decode(PASN_Stream & strm)
  675. {
  676.   if (!PreambleDecode(strm))
  677.     return FALSE;
  678.  
  679.   if (!m_invokeId.Decode(strm))
  680.     return FALSE;
  681.   if (HasOptionalField(e_linkedId) && !m_linkedId.Decode(strm))
  682.     return FALSE;
  683.   if (!m_opcode.Decode(strm))
  684.     return FALSE;
  685.   if (HasOptionalField(e_argument) && !m_argument.Decode(strm))
  686.     return FALSE;
  687.  
  688.   return UnknownExtensionsDecode(strm);
  689. }
  690.  
  691.  
  692. void X880_Invoke::Encode(PASN_Stream & strm) const
  693. {
  694.   PreambleEncode(strm);
  695.  
  696.   m_invokeId.Encode(strm);
  697.   if (HasOptionalField(e_linkedId))
  698.     m_linkedId.Encode(strm);
  699.   m_opcode.Encode(strm);
  700.   if (HasOptionalField(e_argument))
  701.     m_argument.Encode(strm);
  702.  
  703.   UnknownExtensionsEncode(strm);
  704. }
  705.  
  706.  
  707. PObject * X880_Invoke::Clone() const
  708. {
  709. #ifndef PASN_LEANANDMEAN
  710.   PAssert(IsClass(X880_Invoke::Class()), PInvalidCast);
  711. #endif
  712.   return new X880_Invoke(*this);
  713. }
  714.  
  715.  
  716. //
  717. // ReturnResult
  718. //
  719.  
  720. X880_ReturnResult::X880_ReturnResult(unsigned tag, PASN_Object::TagClass tagClass)
  721.   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
  722. {
  723. }
  724.  
  725.  
  726. #ifndef PASN_NOPRINTON
  727. void X880_ReturnResult::PrintOn(ostream & strm) const
  728. {
  729.   int indent = strm.precision() + 2;
  730.   strm << "{\n";
  731.   strm << setw(indent+11) << "invokeId = " << setprecision(indent) << m_invokeId << '\n';
  732.   if (HasOptionalField(e_result))
  733.     strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
  734.   strm << setw(indent-1) << "}";
  735. }
  736. #endif
  737.  
  738.  
  739. PObject::Comparison X880_ReturnResult::Compare(const PObject & obj) const
  740. {
  741. #ifndef PASN_LEANANDMEAN
  742.   PAssert(IsDescendant(X880_ReturnResult::Class()), PInvalidCast);
  743. #endif
  744.   const X880_ReturnResult & other = (const X880_ReturnResult &)obj;
  745.  
  746.   Comparison result;
  747.  
  748.   if ((result = m_invokeId.Compare(other.m_invokeId)) != EqualTo)
  749.     return result;
  750.   if ((result = m_result.Compare(other.m_result)) != EqualTo)
  751.     return result;
  752.  
  753.   return PASN_Sequence::Compare(other);
  754. }
  755.  
  756.  
  757. PINDEX X880_ReturnResult::GetDataLength() const
  758. {
  759.   PINDEX length = 0;
  760.   length += m_invokeId.GetObjectLength();
  761.   if (HasOptionalField(e_result))
  762.     length += m_result.GetObjectLength();
  763.   return length;
  764. }
  765.  
  766.  
  767. BOOL X880_ReturnResult::Decode(PASN_Stream & strm)
  768. {
  769.   if (!PreambleDecode(strm))
  770.     return FALSE;
  771.  
  772.   if (!m_invokeId.Decode(strm))
  773.     return FALSE;
  774.   if (HasOptionalField(e_result) && !m_result.Decode(strm))
  775.     return FALSE;
  776.  
  777.   return UnknownExtensionsDecode(strm);
  778. }
  779.  
  780.  
  781. void X880_ReturnResult::Encode(PASN_Stream & strm) const
  782. {
  783.   PreambleEncode(strm);
  784.  
  785.   m_invokeId.Encode(strm);
  786.   if (HasOptionalField(e_result))
  787.     m_result.Encode(strm);
  788.  
  789.   UnknownExtensionsEncode(strm);
  790. }
  791.  
  792.  
  793. PObject * X880_ReturnResult::Clone() const
  794. {
  795. #ifndef PASN_LEANANDMEAN
  796.   PAssert(IsClass(X880_ReturnResult::Class()), PInvalidCast);
  797. #endif
  798.   return new X880_ReturnResult(*this);
  799. }
  800.  
  801.  
  802. //
  803. // ReturnError
  804. //
  805.  
  806. X880_ReturnError::X880_ReturnError(unsigned tag, PASN_Object::TagClass tagClass)
  807.   : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
  808. {
  809. }
  810.  
  811.  
  812. #ifndef PASN_NOPRINTON
  813. void X880_ReturnError::PrintOn(ostream & strm) const
  814. {
  815.   int indent = strm.precision() + 2;
  816.   strm << "{\n";
  817.   strm << setw(indent+11) << "invokeId = " << setprecision(indent) << m_invokeId << '\n';
  818.   strm << setw(indent+12) << "errorCode = " << setprecision(indent) << m_errorCode << '\n';
  819.   if (HasOptionalField(e_parameter))
  820.     strm << setw(indent+12) << "parameter = " << setprecision(indent) << m_parameter << '\n';
  821.   strm << setw(indent-1) << "}";
  822. }
  823. #endif
  824.  
  825.  
  826. PObject::Comparison X880_ReturnError::Compare(const PObject & obj) const
  827. {
  828. #ifndef PASN_LEANANDMEAN
  829.   PAssert(IsDescendant(X880_ReturnError::Class()), PInvalidCast);
  830. #endif
  831.   const X880_ReturnError & other = (const X880_ReturnError &)obj;
  832.  
  833.   Comparison result;
  834.  
  835.   if ((result = m_invokeId.Compare(other.m_invokeId)) != EqualTo)
  836.     return result;
  837.   if ((result = m_errorCode.Compare(other.m_errorCode)) != EqualTo)
  838.     return result;
  839.   if ((result = m_parameter.Compare(other.m_parameter)) != EqualTo)
  840.     return result;
  841.  
  842.   return PASN_Sequence::Compare(other);
  843. }
  844.  
  845.  
  846. PINDEX X880_ReturnError::GetDataLength() const
  847. {
  848.   PINDEX length = 0;
  849.   length += m_invokeId.GetObjectLength();
  850.   length += m_errorCode.GetObjectLength();
  851.   if (HasOptionalField(e_parameter))
  852.     length += m_parameter.GetObjectLength();
  853.   return length;
  854. }
  855.  
  856.  
  857. BOOL X880_ReturnError::Decode(PASN_Stream & strm)
  858. {
  859.   if (!PreambleDecode(strm))
  860.     return FALSE;
  861.  
  862.   if (!m_invokeId.Decode(strm))
  863.     return FALSE;
  864.   if (!m_errorCode.Decode(strm))
  865.     return FALSE;
  866.   if (HasOptionalField(e_parameter) && !m_parameter.Decode(strm))
  867.     return FALSE;
  868.  
  869.   return UnknownExtensionsDecode(strm);
  870. }
  871.  
  872.  
  873. void X880_ReturnError::Encode(PASN_Stream & strm) const
  874. {
  875.   PreambleEncode(strm);
  876.  
  877.   m_invokeId.Encode(strm);
  878.   m_errorCode.Encode(strm);
  879.   if (HasOptionalField(e_parameter))
  880.     m_parameter.Encode(strm);
  881.  
  882.   UnknownExtensionsEncode(strm);
  883. }
  884.  
  885.  
  886. PObject * X880_ReturnError::Clone() const
  887. {
  888. #ifndef PASN_LEANANDMEAN
  889.   PAssert(IsClass(X880_ReturnError::Class()), PInvalidCast);
  890. #endif
  891.   return new X880_ReturnError(*this);
  892. }
  893.  
  894.  
  895. //
  896. // Reject
  897. //
  898.  
  899. X880_Reject::X880_Reject(unsigned tag, PASN_Object::TagClass tagClass)
  900.   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
  901. {
  902. }
  903.  
  904.  
  905. #ifndef PASN_NOPRINTON
  906. void X880_Reject::PrintOn(ostream & strm) const
  907. {
  908.   int indent = strm.precision() + 2;
  909.   strm << "{\n";
  910.   strm << setw(indent+11) << "invokeId = " << setprecision(indent) << m_invokeId << '\n';
  911.   strm << setw(indent+10) << "problem = " << setprecision(indent) << m_problem << '\n';
  912.   strm << setw(indent-1) << "}";
  913. }
  914. #endif
  915.  
  916.  
  917. PObject::Comparison X880_Reject::Compare(const PObject & obj) const
  918. {
  919. #ifndef PASN_LEANANDMEAN
  920.   PAssert(IsDescendant(X880_Reject::Class()), PInvalidCast);
  921. #endif
  922.   const X880_Reject & other = (const X880_Reject &)obj;
  923.  
  924.   Comparison result;
  925.  
  926.   if ((result = m_invokeId.Compare(other.m_invokeId)) != EqualTo)
  927.     return result;
  928.   if ((result = m_problem.Compare(other.m_problem)) != EqualTo)
  929.     return result;
  930.  
  931.   return PASN_Sequence::Compare(other);
  932. }
  933.  
  934.  
  935. PINDEX X880_Reject::GetDataLength() const
  936. {
  937.   PINDEX length = 0;
  938.   length += m_invokeId.GetObjectLength();
  939.   length += m_problem.GetObjectLength();
  940.   return length;
  941. }
  942.  
  943.  
  944. BOOL X880_Reject::Decode(PASN_Stream & strm)
  945. {
  946.   if (!PreambleDecode(strm))
  947.     return FALSE;
  948.  
  949.   if (!m_invokeId.Decode(strm))
  950.     return FALSE;
  951.   if (!m_problem.Decode(strm))
  952.     return FALSE;
  953.  
  954.   return UnknownExtensionsDecode(strm);
  955. }
  956.  
  957.  
  958. void X880_Reject::Encode(PASN_Stream & strm) const
  959. {
  960.   PreambleEncode(strm);
  961.  
  962.   m_invokeId.Encode(strm);
  963.   m_problem.Encode(strm);
  964.  
  965.   UnknownExtensionsEncode(strm);
  966. }
  967.  
  968.  
  969. PObject * X880_Reject::Clone() const
  970. {
  971. #ifndef PASN_LEANANDMEAN
  972.   PAssert(IsClass(X880_Reject::Class()), PInvalidCast);
  973. #endif
  974.   return new X880_Reject(*this);
  975. }
  976.  
  977.  
  978. #endif // if ! H323_DISABLE_X880
  979.  
  980.  
  981. // End of x880.cxx
  982.