Split capability definitions into own source file
[asterisk/asterisk.git] / channels / h323 / cisco-h225.cxx
1 //
2 // cisco-h225.cxx
3 //
4 // Code automatically generated by asnparse.
5 //
6
7 #ifdef P_USE_PRAGMA
8 #pragma implementation "cisco-h225.h"
9 #endif
10
11 #include <ptlib.h>
12 #include "cisco-h225.h"
13
14 #define new PNEW
15
16
17 #if ! H323_DISABLE_CISCO_H225
18
19 //
20 // RedirectIEinfo
21 //
22
23 CISCO_H225_RedirectIEinfo::CISCO_H225_RedirectIEinfo(unsigned tag, PASN_Object::TagClass tagClass)
24   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
25 {
26 }
27
28
29 #ifndef PASN_NOPRINTON
30 void CISCO_H225_RedirectIEinfo::PrintOn(ostream & strm) const
31 {
32   int indent = strm.precision() + 2;
33   strm << "{\n";
34   strm << setw(indent+13) << "redirectIE = " << setprecision(indent) << m_redirectIE << '\n';
35   strm << setw(indent-1) << setprecision(indent-2) << "}";
36 }
37 #endif
38
39
40 PObject::Comparison CISCO_H225_RedirectIEinfo::Compare(const PObject & obj) const
41 {
42 #ifndef PASN_LEANANDMEAN
43   PAssert(PIsDescendant(&obj, CISCO_H225_RedirectIEinfo), PInvalidCast);
44 #endif
45   const CISCO_H225_RedirectIEinfo & other = (const CISCO_H225_RedirectIEinfo &)obj;
46
47   Comparison result;
48
49   if ((result = m_redirectIE.Compare(other.m_redirectIE)) != EqualTo)
50     return result;
51
52   return PASN_Sequence::Compare(other);
53 }
54
55
56 PINDEX CISCO_H225_RedirectIEinfo::GetDataLength() const
57 {
58   PINDEX length = 0;
59   length += m_redirectIE.GetObjectLength();
60   return length;
61 }
62
63
64 BOOL CISCO_H225_RedirectIEinfo::Decode(PASN_Stream & strm)
65 {
66   if (!PreambleDecode(strm))
67     return FALSE;
68
69   if (!m_redirectIE.Decode(strm))
70     return FALSE;
71
72   return UnknownExtensionsDecode(strm);
73 }
74
75
76 void CISCO_H225_RedirectIEinfo::Encode(PASN_Stream & strm) const
77 {
78   PreambleEncode(strm);
79
80   m_redirectIE.Encode(strm);
81
82   UnknownExtensionsEncode(strm);
83 }
84
85
86 PObject * CISCO_H225_RedirectIEinfo::Clone() const
87 {
88 #ifndef PASN_LEANANDMEAN
89   PAssert(IsClass(CISCO_H225_RedirectIEinfo::Class()), PInvalidCast);
90 #endif
91   return new CISCO_H225_RedirectIEinfo(*this);
92 }
93
94
95 //
96 // ProgIndIEinfo
97 //
98
99 CISCO_H225_ProgIndIEinfo::CISCO_H225_ProgIndIEinfo(unsigned tag, PASN_Object::TagClass tagClass)
100   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
101 {
102 }
103
104
105 #ifndef PASN_NOPRINTON
106 void CISCO_H225_ProgIndIEinfo::PrintOn(ostream & strm) const
107 {
108   int indent = strm.precision() + 2;
109   strm << "{\n";
110   strm << setw(indent+12) << "progIndIE = " << setprecision(indent) << m_progIndIE << '\n';
111   strm << setw(indent-1) << setprecision(indent-2) << "}";
112 }
113 #endif
114
115
116 PObject::Comparison CISCO_H225_ProgIndIEinfo::Compare(const PObject & obj) const
117 {
118 #ifndef PASN_LEANANDMEAN
119   PAssert(PIsDescendant(&obj, CISCO_H225_ProgIndIEinfo), PInvalidCast);
120 #endif
121   const CISCO_H225_ProgIndIEinfo & other = (const CISCO_H225_ProgIndIEinfo &)obj;
122
123   Comparison result;
124
125   if ((result = m_progIndIE.Compare(other.m_progIndIE)) != EqualTo)
126     return result;
127
128   return PASN_Sequence::Compare(other);
129 }
130
131
132 PINDEX CISCO_H225_ProgIndIEinfo::GetDataLength() const
133 {
134   PINDEX length = 0;
135   length += m_progIndIE.GetObjectLength();
136   return length;
137 }
138
139
140 BOOL CISCO_H225_ProgIndIEinfo::Decode(PASN_Stream & strm)
141 {
142   if (!PreambleDecode(strm))
143     return FALSE;
144
145   if (!m_progIndIE.Decode(strm))
146     return FALSE;
147
148   return UnknownExtensionsDecode(strm);
149 }
150
151
152 void CISCO_H225_ProgIndIEinfo::Encode(PASN_Stream & strm) const
153 {
154   PreambleEncode(strm);
155
156   m_progIndIE.Encode(strm);
157
158   UnknownExtensionsEncode(strm);
159 }
160
161
162 PObject * CISCO_H225_ProgIndIEinfo::Clone() const
163 {
164 #ifndef PASN_LEANANDMEAN
165   PAssert(IsClass(CISCO_H225_ProgIndIEinfo::Class()), PInvalidCast);
166 #endif
167   return new CISCO_H225_ProgIndIEinfo(*this);
168 }
169
170
171 //
172 // QsigNonStdInfo
173 //
174
175 CISCO_H225_QsigNonStdInfo::CISCO_H225_QsigNonStdInfo(unsigned tag, PASN_Object::TagClass tagClass)
176   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
177 {
178 }
179
180
181 #ifndef PASN_NOPRINTON
182 void CISCO_H225_QsigNonStdInfo::PrintOn(ostream & strm) const
183 {
184   int indent = strm.precision() + 2;
185   strm << "{\n";
186   strm << setw(indent+6) << "iei = " << setprecision(indent) << m_iei << '\n';
187   strm << setw(indent+10) << "rawMesg = " << setprecision(indent) << m_rawMesg << '\n';
188   strm << setw(indent-1) << setprecision(indent-2) << "}";
189 }
190 #endif
191
192
193 PObject::Comparison CISCO_H225_QsigNonStdInfo::Compare(const PObject & obj) const
194 {
195 #ifndef PASN_LEANANDMEAN
196   PAssert(PIsDescendant(&obj, CISCO_H225_QsigNonStdInfo), PInvalidCast);
197 #endif
198   const CISCO_H225_QsigNonStdInfo & other = (const CISCO_H225_QsigNonStdInfo &)obj;
199
200   Comparison result;
201
202   if ((result = m_iei.Compare(other.m_iei)) != EqualTo)
203     return result;
204   if ((result = m_rawMesg.Compare(other.m_rawMesg)) != EqualTo)
205     return result;
206
207   return PASN_Sequence::Compare(other);
208 }
209
210
211 PINDEX CISCO_H225_QsigNonStdInfo::GetDataLength() const
212 {
213   PINDEX length = 0;
214   length += m_iei.GetObjectLength();
215   length += m_rawMesg.GetObjectLength();
216   return length;
217 }
218
219
220 BOOL CISCO_H225_QsigNonStdInfo::Decode(PASN_Stream & strm)
221 {
222   if (!PreambleDecode(strm))
223     return FALSE;
224
225   if (!m_iei.Decode(strm))
226     return FALSE;
227   if (!m_rawMesg.Decode(strm))
228     return FALSE;
229
230   return UnknownExtensionsDecode(strm);
231 }
232
233
234 void CISCO_H225_QsigNonStdInfo::Encode(PASN_Stream & strm) const
235 {
236   PreambleEncode(strm);
237
238   m_iei.Encode(strm);
239   m_rawMesg.Encode(strm);
240
241   UnknownExtensionsEncode(strm);
242 }
243
244
245 PObject * CISCO_H225_QsigNonStdInfo::Clone() const
246 {
247 #ifndef PASN_LEANANDMEAN
248   PAssert(IsClass(CISCO_H225_QsigNonStdInfo::Class()), PInvalidCast);
249 #endif
250   return new CISCO_H225_QsigNonStdInfo(*this);
251 }
252
253
254 //
255 // CallMgrParam
256 //
257
258 CISCO_H225_CallMgrParam::CISCO_H225_CallMgrParam(unsigned tag, PASN_Object::TagClass tagClass)
259   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
260 {
261 }
262
263
264 #ifndef PASN_NOPRINTON
265 void CISCO_H225_CallMgrParam::PrintOn(ostream & strm) const
266 {
267   int indent = strm.precision() + 2;
268   strm << "{\n";
269   strm << setw(indent+22) << "interclusterVersion = " << setprecision(indent) << m_interclusterVersion << '\n';
270   strm << setw(indent+15) << "enterpriseID = " << setprecision(indent) << m_enterpriseID << '\n';
271   strm << setw(indent-1) << setprecision(indent-2) << "}";
272 }
273 #endif
274
275
276 PObject::Comparison CISCO_H225_CallMgrParam::Compare(const PObject & obj) const
277 {
278 #ifndef PASN_LEANANDMEAN
279   PAssert(PIsDescendant(&obj, CISCO_H225_CallMgrParam), PInvalidCast);
280 #endif
281   const CISCO_H225_CallMgrParam & other = (const CISCO_H225_CallMgrParam &)obj;
282
283   Comparison result;
284
285   if ((result = m_interclusterVersion.Compare(other.m_interclusterVersion)) != EqualTo)
286     return result;
287   if ((result = m_enterpriseID.Compare(other.m_enterpriseID)) != EqualTo)
288     return result;
289
290   return PASN_Sequence::Compare(other);
291 }
292
293
294 PINDEX CISCO_H225_CallMgrParam::GetDataLength() const
295 {
296   PINDEX length = 0;
297   length += m_interclusterVersion.GetObjectLength();
298   length += m_enterpriseID.GetObjectLength();
299   return length;
300 }
301
302
303 BOOL CISCO_H225_CallMgrParam::Decode(PASN_Stream & strm)
304 {
305   if (!PreambleDecode(strm))
306     return FALSE;
307
308   if (!m_interclusterVersion.Decode(strm))
309     return FALSE;
310   if (!m_enterpriseID.Decode(strm))
311     return FALSE;
312
313   return UnknownExtensionsDecode(strm);
314 }
315
316
317 void CISCO_H225_CallMgrParam::Encode(PASN_Stream & strm) const
318 {
319   PreambleEncode(strm);
320
321   m_interclusterVersion.Encode(strm);
322   m_enterpriseID.Encode(strm);
323
324   UnknownExtensionsEncode(strm);
325 }
326
327
328 PObject * CISCO_H225_CallMgrParam::Clone() const
329 {
330 #ifndef PASN_LEANANDMEAN
331   PAssert(IsClass(CISCO_H225_CallMgrParam::Class()), PInvalidCast);
332 #endif
333   return new CISCO_H225_CallMgrParam(*this);
334 }
335
336
337 //
338 // CallPreserveParam
339 //
340
341 CISCO_H225_CallPreserveParam::CISCO_H225_CallPreserveParam(unsigned tag, PASN_Object::TagClass tagClass)
342   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
343 {
344 }
345
346
347 #ifndef PASN_NOPRINTON
348 void CISCO_H225_CallPreserveParam::PrintOn(ostream & strm) const
349 {
350   int indent = strm.precision() + 2;
351   strm << "{\n";
352   strm << setw(indent+17) << "callPreserveIE = " << setprecision(indent) << m_callPreserveIE << '\n';
353   strm << setw(indent-1) << setprecision(indent-2) << "}";
354 }
355 #endif
356
357
358 PObject::Comparison CISCO_H225_CallPreserveParam::Compare(const PObject & obj) const
359 {
360 #ifndef PASN_LEANANDMEAN
361   PAssert(PIsDescendant(&obj, CISCO_H225_CallPreserveParam), PInvalidCast);
362 #endif
363   const CISCO_H225_CallPreserveParam & other = (const CISCO_H225_CallPreserveParam &)obj;
364
365   Comparison result;
366
367   if ((result = m_callPreserveIE.Compare(other.m_callPreserveIE)) != EqualTo)
368     return result;
369
370   return PASN_Sequence::Compare(other);
371 }
372
373
374 PINDEX CISCO_H225_CallPreserveParam::GetDataLength() const
375 {
376   PINDEX length = 0;
377   length += m_callPreserveIE.GetObjectLength();
378   return length;
379 }
380
381
382 BOOL CISCO_H225_CallPreserveParam::Decode(PASN_Stream & strm)
383 {
384   if (!PreambleDecode(strm))
385     return FALSE;
386
387   if (!m_callPreserveIE.Decode(strm))
388     return FALSE;
389
390   return UnknownExtensionsDecode(strm);
391 }
392
393
394 void CISCO_H225_CallPreserveParam::Encode(PASN_Stream & strm) const
395 {
396   PreambleEncode(strm);
397
398   m_callPreserveIE.Encode(strm);
399
400   UnknownExtensionsEncode(strm);
401 }
402
403
404 PObject * CISCO_H225_CallPreserveParam::Clone() const
405 {
406 #ifndef PASN_LEANANDMEAN
407   PAssert(IsClass(CISCO_H225_CallPreserveParam::Class()), PInvalidCast);
408 #endif
409   return new CISCO_H225_CallPreserveParam(*this);
410 }
411
412
413 //
414 // CallSignallingParam
415 //
416
417 CISCO_H225_CallSignallingParam::CISCO_H225_CallSignallingParam(unsigned tag, PASN_Object::TagClass tagClass)
418   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
419 {
420   m_connectedNumber.SetConstraints(PASN_Object::FixedConstraint, 1, 127);
421 }
422
423
424 #ifndef PASN_NOPRINTON
425 void CISCO_H225_CallSignallingParam::PrintOn(ostream & strm) const
426 {
427   int indent = strm.precision() + 2;
428   strm << "{\n";
429   if (HasOptionalField(e_connectedNumber))
430     strm << setw(indent+18) << "connectedNumber = " << setprecision(indent) << m_connectedNumber << '\n';
431   strm << setw(indent-1) << setprecision(indent-2) << "}";
432 }
433 #endif
434
435
436 PObject::Comparison CISCO_H225_CallSignallingParam::Compare(const PObject & obj) const
437 {
438 #ifndef PASN_LEANANDMEAN
439   PAssert(PIsDescendant(&obj, CISCO_H225_CallSignallingParam), PInvalidCast);
440 #endif
441   const CISCO_H225_CallSignallingParam & other = (const CISCO_H225_CallSignallingParam &)obj;
442
443   Comparison result;
444
445   if ((result = m_connectedNumber.Compare(other.m_connectedNumber)) != EqualTo)
446     return result;
447
448   return PASN_Sequence::Compare(other);
449 }
450
451
452 PINDEX CISCO_H225_CallSignallingParam::GetDataLength() const
453 {
454   PINDEX length = 0;
455   if (HasOptionalField(e_connectedNumber))
456     length += m_connectedNumber.GetObjectLength();
457   return length;
458 }
459
460
461 BOOL CISCO_H225_CallSignallingParam::Decode(PASN_Stream & strm)
462 {
463   if (!PreambleDecode(strm))
464     return FALSE;
465
466   if (HasOptionalField(e_connectedNumber) && !m_connectedNumber.Decode(strm))
467     return FALSE;
468
469   return UnknownExtensionsDecode(strm);
470 }
471
472
473 void CISCO_H225_CallSignallingParam::Encode(PASN_Stream & strm) const
474 {
475   PreambleEncode(strm);
476
477   if (HasOptionalField(e_connectedNumber))
478     m_connectedNumber.Encode(strm);
479
480   UnknownExtensionsEncode(strm);
481 }
482
483
484 PObject * CISCO_H225_CallSignallingParam::Clone() const
485 {
486 #ifndef PASN_LEANANDMEAN
487   PAssert(IsClass(CISCO_H225_CallSignallingParam::Class()), PInvalidCast);
488 #endif
489   return new CISCO_H225_CallSignallingParam(*this);
490 }
491
492
493 //
494 // CommonParam
495 //
496
497 CISCO_H225_CommonParam::CISCO_H225_CommonParam(unsigned tag, PASN_Object::TagClass tagClass)
498   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
499 {
500 }
501
502
503 #ifndef PASN_NOPRINTON
504 void CISCO_H225_CommonParam::PrintOn(ostream & strm) const
505 {
506   int indent = strm.precision() + 2;
507   strm << "{\n";
508   strm << setw(indent+17) << "redirectIEinfo = " << setprecision(indent) << m_redirectIEinfo << '\n';
509   strm << setw(indent-1) << setprecision(indent-2) << "}";
510 }
511 #endif
512
513
514 PObject::Comparison CISCO_H225_CommonParam::Compare(const PObject & obj) const
515 {
516 #ifndef PASN_LEANANDMEAN
517   PAssert(PIsDescendant(&obj, CISCO_H225_CommonParam), PInvalidCast);
518 #endif
519   const CISCO_H225_CommonParam & other = (const CISCO_H225_CommonParam &)obj;
520
521   Comparison result;
522
523   if ((result = m_redirectIEinfo.Compare(other.m_redirectIEinfo)) != EqualTo)
524     return result;
525
526   return PASN_Sequence::Compare(other);
527 }
528
529
530 PINDEX CISCO_H225_CommonParam::GetDataLength() const
531 {
532   PINDEX length = 0;
533   length += m_redirectIEinfo.GetObjectLength();
534   return length;
535 }
536
537
538 BOOL CISCO_H225_CommonParam::Decode(PASN_Stream & strm)
539 {
540   if (!PreambleDecode(strm))
541     return FALSE;
542
543   if (!m_redirectIEinfo.Decode(strm))
544     return FALSE;
545
546   return UnknownExtensionsDecode(strm);
547 }
548
549
550 void CISCO_H225_CommonParam::Encode(PASN_Stream & strm) const
551 {
552   PreambleEncode(strm);
553
554   m_redirectIEinfo.Encode(strm);
555
556   UnknownExtensionsEncode(strm);
557 }
558
559
560 PObject * CISCO_H225_CommonParam::Clone() const
561 {
562 #ifndef PASN_LEANANDMEAN
563   PAssert(IsClass(CISCO_H225_CommonParam::Class()), PInvalidCast);
564 #endif
565   return new CISCO_H225_CommonParam(*this);
566 }
567
568
569 //
570 // ProgIndParam
571 //
572
573 CISCO_H225_ProgIndParam::CISCO_H225_ProgIndParam(unsigned tag, PASN_Object::TagClass tagClass)
574   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
575 {
576 }
577
578
579 #ifndef PASN_NOPRINTON
580 void CISCO_H225_ProgIndParam::PrintOn(ostream & strm) const
581 {
582   int indent = strm.precision() + 2;
583   strm << "{\n";
584   strm << setw(indent+16) << "progIndIEinfo = " << setprecision(indent) << m_progIndIEinfo << '\n';
585   strm << setw(indent-1) << setprecision(indent-2) << "}";
586 }
587 #endif
588
589
590 PObject::Comparison CISCO_H225_ProgIndParam::Compare(const PObject & obj) const
591 {
592 #ifndef PASN_LEANANDMEAN
593   PAssert(PIsDescendant(&obj, CISCO_H225_ProgIndParam), PInvalidCast);
594 #endif
595   const CISCO_H225_ProgIndParam & other = (const CISCO_H225_ProgIndParam &)obj;
596
597   Comparison result;
598
599   if ((result = m_progIndIEinfo.Compare(other.m_progIndIEinfo)) != EqualTo)
600     return result;
601
602   return PASN_Sequence::Compare(other);
603 }
604
605
606 PINDEX CISCO_H225_ProgIndParam::GetDataLength() const
607 {
608   PINDEX length = 0;
609   length += m_progIndIEinfo.GetObjectLength();
610   return length;
611 }
612
613
614 BOOL CISCO_H225_ProgIndParam::Decode(PASN_Stream & strm)
615 {
616   if (!PreambleDecode(strm))
617     return FALSE;
618
619   if (!m_progIndIEinfo.Decode(strm))
620     return FALSE;
621
622   return UnknownExtensionsDecode(strm);
623 }
624
625
626 void CISCO_H225_ProgIndParam::Encode(PASN_Stream & strm) const
627 {
628   PreambleEncode(strm);
629
630   m_progIndIEinfo.Encode(strm);
631
632   UnknownExtensionsEncode(strm);
633 }
634
635
636 PObject * CISCO_H225_ProgIndParam::Clone() const
637 {
638 #ifndef PASN_LEANANDMEAN
639   PAssert(IsClass(CISCO_H225_ProgIndParam::Class()), PInvalidCast);
640 #endif
641   return new CISCO_H225_ProgIndParam(*this);
642 }
643
644
645 //
646 // ProtoParam
647 //
648
649 CISCO_H225_ProtoParam::CISCO_H225_ProtoParam(unsigned tag, PASN_Object::TagClass tagClass)
650   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
651 {
652 }
653
654
655 #ifndef PASN_NOPRINTON
656 void CISCO_H225_ProtoParam::PrintOn(ostream & strm) const
657 {
658   int indent = strm.precision() + 2;
659   strm << "{\n";
660   strm << setw(indent+17) << "qsigNonStdInfo = " << setprecision(indent) << m_qsigNonStdInfo << '\n';
661   strm << setw(indent-1) << setprecision(indent-2) << "}";
662 }
663 #endif
664
665
666 PObject::Comparison CISCO_H225_ProtoParam::Compare(const PObject & obj) const
667 {
668 #ifndef PASN_LEANANDMEAN
669   PAssert(PIsDescendant(&obj, CISCO_H225_ProtoParam), PInvalidCast);
670 #endif
671   const CISCO_H225_ProtoParam & other = (const CISCO_H225_ProtoParam &)obj;
672
673   Comparison result;
674
675   if ((result = m_qsigNonStdInfo.Compare(other.m_qsigNonStdInfo)) != EqualTo)
676     return result;
677
678   return PASN_Sequence::Compare(other);
679 }
680
681
682 PINDEX CISCO_H225_ProtoParam::GetDataLength() const
683 {
684   PINDEX length = 0;
685   length += m_qsigNonStdInfo.GetObjectLength();
686   return length;
687 }
688
689
690 BOOL CISCO_H225_ProtoParam::Decode(PASN_Stream & strm)
691 {
692   if (!PreambleDecode(strm))
693     return FALSE;
694
695   if (!m_qsigNonStdInfo.Decode(strm))
696     return FALSE;
697
698   return UnknownExtensionsDecode(strm);
699 }
700
701
702 void CISCO_H225_ProtoParam::Encode(PASN_Stream & strm) const
703 {
704   PreambleEncode(strm);
705
706   m_qsigNonStdInfo.Encode(strm);
707
708   UnknownExtensionsEncode(strm);
709 }
710
711
712 PObject * CISCO_H225_ProtoParam::Clone() const
713 {
714 #ifndef PASN_LEANANDMEAN
715   PAssert(IsClass(CISCO_H225_ProtoParam::Class()), PInvalidCast);
716 #endif
717   return new CISCO_H225_ProtoParam(*this);
718 }
719
720
721 //
722 // H323_UU_NonStdInfo
723 //
724
725 CISCO_H225_H323_UU_NonStdInfo::CISCO_H225_H323_UU_NonStdInfo(unsigned tag, PASN_Object::TagClass tagClass)
726   : PASN_Sequence(tag, tagClass, 3, TRUE, 6)
727 {
728 }
729
730
731 #ifndef PASN_NOPRINTON
732 void CISCO_H225_H323_UU_NonStdInfo::PrintOn(ostream & strm) const
733 {
734   int indent = strm.precision() + 2;
735   strm << "{\n";
736   if (HasOptionalField(e_version))
737     strm << setw(indent+10) << "version = " << setprecision(indent) << m_version << '\n';
738   if (HasOptionalField(e_protoParam))
739     strm << setw(indent+13) << "protoParam = " << setprecision(indent) << m_protoParam << '\n';
740   if (HasOptionalField(e_commonParam))
741     strm << setw(indent+14) << "commonParam = " << setprecision(indent) << m_commonParam << '\n';
742   if (HasOptionalField(e_progIndParam))
743     strm << setw(indent+15) << "progIndParam = " << setprecision(indent) << m_progIndParam << '\n';
744   if (HasOptionalField(e_dummy1))
745     strm << setw(indent+9) << "dummy1 = " << setprecision(indent) << m_dummy1 << '\n';
746   if (HasOptionalField(e_callMgrParam))
747     strm << setw(indent+15) << "callMgrParam = " << setprecision(indent) << m_callMgrParam << '\n';
748   if (HasOptionalField(e_callSignallingParam))
749     strm << setw(indent+22) << "callSignallingParam = " << setprecision(indent) << m_callSignallingParam << '\n';
750   if (HasOptionalField(e_dummy2))
751     strm << setw(indent+9) << "dummy2 = " << setprecision(indent) << m_dummy2 << '\n';
752   if (HasOptionalField(e_callPreserveParam))
753     strm << setw(indent+20) << "callPreserveParam = " << setprecision(indent) << m_callPreserveParam << '\n';
754   strm << setw(indent-1) << setprecision(indent-2) << "}";
755 }
756 #endif
757
758
759 PObject::Comparison CISCO_H225_H323_UU_NonStdInfo::Compare(const PObject & obj) const
760 {
761 #ifndef PASN_LEANANDMEAN
762   PAssert(PIsDescendant(&obj, CISCO_H225_H323_UU_NonStdInfo), PInvalidCast);
763 #endif
764   const CISCO_H225_H323_UU_NonStdInfo & other = (const CISCO_H225_H323_UU_NonStdInfo &)obj;
765
766   Comparison result;
767
768   if ((result = m_version.Compare(other.m_version)) != EqualTo)
769     return result;
770   if ((result = m_protoParam.Compare(other.m_protoParam)) != EqualTo)
771     return result;
772   if ((result = m_commonParam.Compare(other.m_commonParam)) != EqualTo)
773     return result;
774
775   return PASN_Sequence::Compare(other);
776 }
777
778
779 PINDEX CISCO_H225_H323_UU_NonStdInfo::GetDataLength() const
780 {
781   PINDEX length = 0;
782   if (HasOptionalField(e_version))
783     length += m_version.GetObjectLength();
784   if (HasOptionalField(e_protoParam))
785     length += m_protoParam.GetObjectLength();
786   if (HasOptionalField(e_commonParam))
787     length += m_commonParam.GetObjectLength();
788   return length;
789 }
790
791
792 BOOL CISCO_H225_H323_UU_NonStdInfo::Decode(PASN_Stream & strm)
793 {
794   if (!PreambleDecode(strm))
795     return FALSE;
796
797   if (HasOptionalField(e_version) && !m_version.Decode(strm))
798     return FALSE;
799   if (HasOptionalField(e_protoParam) && !m_protoParam.Decode(strm))
800     return FALSE;
801   if (HasOptionalField(e_commonParam) && !m_commonParam.Decode(strm))
802     return FALSE;
803   if (!KnownExtensionDecode(strm, e_progIndParam, m_progIndParam))
804     return FALSE;
805   if (!KnownExtensionDecode(strm, e_dummy1, m_dummy1))
806     return FALSE;
807   if (!KnownExtensionDecode(strm, e_callMgrParam, m_callMgrParam))
808     return FALSE;
809   if (!KnownExtensionDecode(strm, e_callSignallingParam, m_callSignallingParam))
810     return FALSE;
811   if (!KnownExtensionDecode(strm, e_dummy2, m_dummy2))
812     return FALSE;
813   if (!KnownExtensionDecode(strm, e_callPreserveParam, m_callPreserveParam))
814     return FALSE;
815
816   return UnknownExtensionsDecode(strm);
817 }
818
819
820 void CISCO_H225_H323_UU_NonStdInfo::Encode(PASN_Stream & strm) const
821 {
822   PreambleEncode(strm);
823
824   if (HasOptionalField(e_version))
825     m_version.Encode(strm);
826   if (HasOptionalField(e_protoParam))
827     m_protoParam.Encode(strm);
828   if (HasOptionalField(e_commonParam))
829     m_commonParam.Encode(strm);
830   KnownExtensionEncode(strm, e_progIndParam, m_progIndParam);
831   KnownExtensionEncode(strm, e_dummy1, m_dummy1);
832   KnownExtensionEncode(strm, e_callMgrParam, m_callMgrParam);
833   KnownExtensionEncode(strm, e_callSignallingParam, m_callSignallingParam);
834   KnownExtensionEncode(strm, e_dummy2, m_dummy2);
835   KnownExtensionEncode(strm, e_callPreserveParam, m_callPreserveParam);
836
837   UnknownExtensionsEncode(strm);
838 }
839
840
841 PObject * CISCO_H225_H323_UU_NonStdInfo::Clone() const
842 {
843 #ifndef PASN_LEANANDMEAN
844   PAssert(IsClass(CISCO_H225_H323_UU_NonStdInfo::Class()), PInvalidCast);
845 #endif
846   return new CISCO_H225_H323_UU_NonStdInfo(*this);
847 }
848
849
850 #endif // if ! H323_DISABLE_CISCO_H225
851
852
853 // End of cisco-h225.cxx