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