]> git.saurik.com Git - apple/security.git/blame - SecurityASN1/inc/sm_x501if.h
projects / apple / security.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Security-28.tar.gz
[apple/security.git] / SecurityASN1 / inc / sm_x501if.h
CommitLineData
bac41a7b
A		 1// NOTE: this is a machine generated file--editing not recommended
2//
3// sm_x501if.h - class definitions for ASN.1 module InformationFramework
4//
5// This file was generated by snacc on Wed Jun 27 16:40:55 2001
6// UBC snacc by Mike Sample
7// A couple of enhancements made by IBM European Networking Center
8
9#ifndef _sm_x501if_h_
10#define _sm_x501if_h_
11
12
13//------------------------------------------------------------------------------
14// class declarations:
15
16class AttributeTypeAndDistinguishedValueSetOfSeqSetOf;
17class AttributeTypeAndDistinguishedValueSetOfSeq;
18class AttributeTypeAndDistinguishedValueSetOf;
19class AttributeSetOf;
20class Attribute;
21class AttributeTypeAndDistinguishedValue;
22class RelativeDistinguishedName;
23class RDNSequence;
24class Attributes;
25class Name;
26
27//------------------------------------------------------------------------------
28// class definitions:
29
30typedef enum InformationFrameworkAnyId
31{
32
33} InformationFrameworkAnyId;
34
35
36/* OBJECT IDENTIFIER */
37typedef AsnOid AttributeType;
38
39/* ANY */
40typedef AsnAny AttributeValue;
41
42class AttributeTypeAndDistinguishedValueSetOfSeqSetOf: public AsnType
43{
44protected:
45 unsigned long int count;
46 struct AsnListElmt
47 {
48 AsnListElmt *next;
49 AsnListElmt *prev;
50 AsnAny *elmt;
51 } *first, *curr, *last;
52
53public:
54 AttributeTypeAndDistinguishedValueSetOfSeqSetOf() { count = 0; first = curr = last = NULL; }
55 AttributeTypeAndDistinguishedValueSetOfSeqSetOf (const AttributeTypeAndDistinguishedValueSetOfSeqSetOf &);
56 virtual ~AttributeTypeAndDistinguishedValueSetOfSeqSetOf();
57 virtual AsnType *Clone() const;
58
59 virtual AsnType *Copy() const;
60
61 AttributeTypeAndDistinguishedValueSetOfSeqSetOf &operator = (const AttributeTypeAndDistinguishedValueSetOfSeqSetOf &);
62 void SetCurrElmt (unsigned long int index);
63 unsigned long int GetCurrElmtIndex();
64 void SetCurrToFirst() { curr = first; }
65 void SetCurrToLast() { curr = last; }
66 // reading member fcns
67 int Count() const { return count; }
68 // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
69 AsnAny *First() const { return count > 0 ? first->elmt : NULL; }
70 AsnAny *Last() const { return count > 0 ? last->elmt : NULL; }
71 AsnAny *Curr() const { return curr ? curr->elmt : NULL; }
72 AsnAny *Next() const { return curr && curr->next ? curr->next->elmt : NULL; }
73 AsnAny *Prev() const { return curr && curr->prev ? curr->prev->elmt : NULL; }
74
75 // routines that move the curr elmt
76 AsnAny *GoNext() { if (curr) curr = curr->next; return Curr(); }
77 AsnAny *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
78
79 // write & alloc fcns - returns new elmt
80 AsnAny *Append(); // add elmt to end of list
81 AsnAny *Prepend(); // add elmt to beginning of list
82 AsnAny *InsertBefore(); //insert elmt before current elmt
83 AsnAny *InsertAfter(); //insert elmt after current elmt
84
85 // write & alloc & copy - returns list after copying elmt
86 AttributeTypeAndDistinguishedValueSetOfSeqSetOf &AppendCopy (AsnAny &elmt); // add elmt to end of list
87 AttributeTypeAndDistinguishedValueSetOfSeqSetOf &PrependCopy (AsnAny &elmt); // add elmt to beginning of list
88 AttributeTypeAndDistinguishedValueSetOfSeqSetOf &InsertBeforeAndCopy (AsnAny &elmt); //insert elmt before current elmt
89 AttributeTypeAndDistinguishedValueSetOfSeqSetOf &InsertAfterAndCopy (AsnAny &elmt); //insert elmt after current elmt
90
91 // removing the current elmt from the list
92 void RemoveCurrFromList();
93
94 // encode and decode routines
95 AsnLen BEnc (BUF_TYPE b);
96 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
97 AsnLen BEncContent (BUF_TYPE b);
98 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
99
100 PDU_MEMBER_MACROS
101 void Print (ostream &os) const;
102};
103
104
105class AttributeTypeAndDistinguishedValueSetOfSeq: public AsnType
106{
107public:
108 AsnOid *distingAttrValue;
109 AttributeTypeAndDistinguishedValueSetOfSeqSetOf contextList;
110
111 AttributeTypeAndDistinguishedValueSetOfSeq();
112 AttributeTypeAndDistinguishedValueSetOfSeq (const AttributeTypeAndDistinguishedValueSetOfSeq &);
113 virtual ~AttributeTypeAndDistinguishedValueSetOfSeq();
114 virtual AsnType *Clone() const;
115
116 virtual AsnType *Copy() const;
117
118 AttributeTypeAndDistinguishedValueSetOfSeq &operator = (const AttributeTypeAndDistinguishedValueSetOfSeq &);
119 AsnLen BEncContent (BUF_TYPE b);
120 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
121
122 AsnLen BEnc (BUF_TYPE b);
123 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
124 int BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
125 int BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
126
127 void Print (ostream &os) const;
128};
129
130
131class AttributeTypeAndDistinguishedValueSetOf: public AsnType
132{
133protected:
134 unsigned long int count;
135 struct AsnListElmt
136 {
137 AsnListElmt *next;
138 AsnListElmt *prev;
139 AttributeTypeAndDistinguishedValueSetOfSeq *elmt;
140 } *first, *curr, *last;
141
142public:
143 AttributeTypeAndDistinguishedValueSetOf() { count = 0; first = curr = last = NULL; }
144 AttributeTypeAndDistinguishedValueSetOf (const AttributeTypeAndDistinguishedValueSetOf &);
145 virtual ~AttributeTypeAndDistinguishedValueSetOf();
146 virtual AsnType *Clone() const;
147
148 virtual AsnType *Copy() const;
149
150 AttributeTypeAndDistinguishedValueSetOf &operator = (const AttributeTypeAndDistinguishedValueSetOf &);
151 void SetCurrElmt (unsigned long int index);
152 unsigned long int GetCurrElmtIndex();
153 void SetCurrToFirst() { curr = first; }
154 void SetCurrToLast() { curr = last; }
155 // reading member fcns
156 int Count() const { return count; }
157 // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
158 AttributeTypeAndDistinguishedValueSetOfSeq *First() const { return count > 0 ? first->elmt : NULL; }
159 AttributeTypeAndDistinguishedValueSetOfSeq *Last() const { return count > 0 ? last->elmt : NULL; }
160 AttributeTypeAndDistinguishedValueSetOfSeq *Curr() const { return curr ? curr->elmt : NULL; }
161 AttributeTypeAndDistinguishedValueSetOfSeq *Next() const { return curr && curr->next ? curr->next->elmt : NULL; }
162 AttributeTypeAndDistinguishedValueSetOfSeq *Prev() const { return curr && curr->prev ? curr->prev->elmt : NULL; }
163
164 // routines that move the curr elmt
165 AttributeTypeAndDistinguishedValueSetOfSeq *GoNext() { if (curr) curr = curr->next; return Curr(); }
166 AttributeTypeAndDistinguishedValueSetOfSeq *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
167
168 // write & alloc fcns - returns new elmt
169 AttributeTypeAndDistinguishedValueSetOfSeq *Append(); // add elmt to end of list
170 AttributeTypeAndDistinguishedValueSetOfSeq *Prepend(); // add elmt to beginning of list
171 AttributeTypeAndDistinguishedValueSetOfSeq *InsertBefore(); //insert elmt before current elmt
172 AttributeTypeAndDistinguishedValueSetOfSeq *InsertAfter(); //insert elmt after current elmt
173
174 // write & alloc & copy - returns list after copying elmt
175 AttributeTypeAndDistinguishedValueSetOf &AppendCopy (AttributeTypeAndDistinguishedValueSetOfSeq &elmt); // add elmt to end of list
176 AttributeTypeAndDistinguishedValueSetOf &PrependCopy (AttributeTypeAndDistinguishedValueSetOfSeq &elmt); // add elmt to beginning of list
177 AttributeTypeAndDistinguishedValueSetOf &InsertBeforeAndCopy (AttributeTypeAndDistinguishedValueSetOfSeq &elmt); //insert elmt before current elmt
178 AttributeTypeAndDistinguishedValueSetOf &InsertAfterAndCopy (AttributeTypeAndDistinguishedValueSetOfSeq &elmt); //insert elmt after current elmt
179
180 // removing the current elmt from the list
181 void RemoveCurrFromList();
182
183 // encode and decode routines
184 AsnLen BEnc (BUF_TYPE b);
185 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
186 AsnLen BEncContent (BUF_TYPE b);
187 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
188
189 PDU_MEMBER_MACROS
190 void Print (ostream &os) const;
191};
192
193
194class AttributeSetOf: public AsnType
195{
196protected:
197 unsigned long int count;
198 struct AsnListElmt
199 {
200 AsnListElmt *next;
201 AsnListElmt *prev;
202 AttributeValue *elmt;
203 } *first, *curr, *last;
204
205public:
206 AttributeSetOf() { count = 0; first = curr = last = NULL; }
207 AttributeSetOf (const AttributeSetOf &);
208 virtual ~AttributeSetOf();
209 virtual AsnType *Clone() const;
210
211 virtual AsnType *Copy() const;
212
213 AttributeSetOf &operator = (const AttributeSetOf &);
214 void SetCurrElmt (unsigned long int index);
215 unsigned long int GetCurrElmtIndex();
216 void SetCurrToFirst() { curr = first; }
217 void SetCurrToLast() { curr = last; }
218 // reading member fcns
219 int Count() const { return count; }
220 // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
221 AttributeValue *First() const { return count > 0 ? first->elmt : NULL; }
222 AttributeValue *Last() const { return count > 0 ? last->elmt : NULL; }
223 AttributeValue *Curr() const { return curr ? curr->elmt : NULL; }
224 AttributeValue *Next() const { return curr && curr->next ? curr->next->elmt : NULL; }
225 AttributeValue *Prev() const { return curr && curr->prev ? curr->prev->elmt : NULL; }
226
227 // routines that move the curr elmt
228 AttributeValue *GoNext() { if (curr) curr = curr->next; return Curr(); }
229 AttributeValue *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
230
231 // write & alloc fcns - returns new elmt
232 AttributeValue *Append(); // add elmt to end of list
233 AttributeValue *Prepend(); // add elmt to beginning of list
234 AttributeValue *InsertBefore(); //insert elmt before current elmt
235 AttributeValue *InsertAfter(); //insert elmt after current elmt
236
237 // write & alloc & copy - returns list after copying elmt
238 AttributeSetOf &AppendCopy (AttributeValue &elmt); // add elmt to end of list
239 AttributeSetOf &PrependCopy (AttributeValue &elmt); // add elmt to beginning of list
240 AttributeSetOf &InsertBeforeAndCopy (AttributeValue &elmt); //insert elmt before current elmt
241 AttributeSetOf &InsertAfterAndCopy (AttributeValue &elmt); //insert elmt after current elmt
242
243 // removing the current elmt from the list
244 void RemoveCurrFromList();
245
246 // encode and decode routines
247 AsnLen BEnc (BUF_TYPE b);
248 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
249 AsnLen BEncContent (BUF_TYPE b);
250 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
251
252 PDU_MEMBER_MACROS
253 void Print (ostream &os) const;
254};
255
256
257class Attribute: public AsnType
258{
259public:
260 AttributeType type;
261 AttributeSetOf values;
262
263 Attribute();
264 Attribute (const Attribute &);
265 virtual ~Attribute();
266 virtual AsnType *Clone() const;
267
268 virtual AsnType *Copy() const;
269
270 Attribute &operator = (const Attribute &);
271 AsnLen BEncContent (BUF_TYPE b);
272 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
273
274 AsnLen BEnc (BUF_TYPE b);
275 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
276 int BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
277 int BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
278
279 void Print (ostream &os) const;
280};
281
282
283class AttributeTypeAndDistinguishedValue: public AsnType
284{
285public:
286 AsnOid type;
287 AsnAny value;
288 AsnBool *primaryDistinguished;
289 AttributeTypeAndDistinguishedValueSetOf *valuesWithContext;
290
291 AttributeTypeAndDistinguishedValue();
292 AttributeTypeAndDistinguishedValue (const AttributeTypeAndDistinguishedValue &);
293 virtual ~AttributeTypeAndDistinguishedValue();
294 virtual AsnType *Clone() const;
295
296 virtual AsnType *Copy() const;
297
298 AttributeTypeAndDistinguishedValue &operator = (const AttributeTypeAndDistinguishedValue &);
299 AsnLen BEncContent (BUF_TYPE b);
300 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
301
302 AsnLen BEnc (BUF_TYPE b);
303 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
304 int BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
305 int BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
306
307 void Print (ostream &os) const;
308};
309
310
311class RelativeDistinguishedName: public AsnType
312{
313protected:
314 unsigned long int count;
315 struct AsnListElmt
316 {
317 AsnListElmt *next;
318 AsnListElmt *prev;
319 AttributeTypeAndDistinguishedValue *elmt;
320 } *first, *curr, *last;
321
322public:
323 RelativeDistinguishedName() { count = 0; first = curr = last = NULL; }
324 RelativeDistinguishedName (const RelativeDistinguishedName &);
325 virtual ~RelativeDistinguishedName();
326 virtual AsnType *Clone() const;
327
328 virtual AsnType *Copy() const;
329
330 RelativeDistinguishedName &operator = (const RelativeDistinguishedName &);
331 void SetCurrElmt (unsigned long int index);
332 unsigned long int GetCurrElmtIndex();
333 void SetCurrToFirst() { curr = first; }
334 void SetCurrToLast() { curr = last; }
335 // reading member fcns
336 int Count() const { return count; }
337 // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
338 AttributeTypeAndDistinguishedValue *First() const { return count > 0 ? first->elmt : NULL; }
339 AttributeTypeAndDistinguishedValue *Last() const { return count > 0 ? last->elmt : NULL; }
340 AttributeTypeAndDistinguishedValue *Curr() const { return curr ? curr->elmt : NULL; }
341 AttributeTypeAndDistinguishedValue *Next() const { return curr && curr->next ? curr->next->elmt : NULL; }
342 AttributeTypeAndDistinguishedValue *Prev() const { return curr && curr->prev ? curr->prev->elmt : NULL; }
343
344 // routines that move the curr elmt
345 AttributeTypeAndDistinguishedValue *GoNext() { if (curr) curr = curr->next; return Curr(); }
346 AttributeTypeAndDistinguishedValue *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
347
348 // write & alloc fcns - returns new elmt
349 AttributeTypeAndDistinguishedValue *Append(); // add elmt to end of list
350 AttributeTypeAndDistinguishedValue *Prepend(); // add elmt to beginning of list
351 AttributeTypeAndDistinguishedValue *InsertBefore(); //insert elmt before current elmt
352 AttributeTypeAndDistinguishedValue *InsertAfter(); //insert elmt after current elmt
353
354 // write & alloc & copy - returns list after copying elmt
355 RelativeDistinguishedName &AppendCopy (AttributeTypeAndDistinguishedValue &elmt); // add elmt to end of list
356 RelativeDistinguishedName &PrependCopy (AttributeTypeAndDistinguishedValue &elmt); // add elmt to beginning of list
357 RelativeDistinguishedName &InsertBeforeAndCopy (AttributeTypeAndDistinguishedValue &elmt); //insert elmt before current elmt
358 RelativeDistinguishedName &InsertAfterAndCopy (AttributeTypeAndDistinguishedValue &elmt); //insert elmt after current elmt
359
360 // removing the current elmt from the list
361 void RemoveCurrFromList();
362
363 // encode and decode routines
364 AsnLen BEnc (BUF_TYPE b);
365 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
366 AsnLen BEncContent (BUF_TYPE b);
367 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
368
369 PDU_MEMBER_MACROS
370 void Print (ostream &os) const;
371};
372
373
374class RDNSequence: public AsnType
375{
376protected:
377 unsigned long int count;
378 struct AsnListElmt
379 {
380 AsnListElmt *next;
381 AsnListElmt *prev;
382 RelativeDistinguishedName *elmt;
383 } *first, *curr, *last;
384
385public:
386 RDNSequence() { count = 0; first = curr = last = NULL; }
387 RDNSequence (const RDNSequence &);
388 virtual ~RDNSequence();
389 virtual AsnType *Clone() const;
390
391 virtual AsnType *Copy() const;
392
393 RDNSequence &operator = (const RDNSequence &);
394 void SetCurrElmt (unsigned long int index);
395 unsigned long int GetCurrElmtIndex();
396 void SetCurrToFirst() { curr = first; }
397 void SetCurrToLast() { curr = last; }
398 // reading member fcns
399 int Count() const { return count; }
400 // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
401 RelativeDistinguishedName *First() const { return count > 0 ? first->elmt : NULL; }
402 RelativeDistinguishedName *Last() const { return count > 0 ? last->elmt : NULL; }
403 RelativeDistinguishedName *Curr() const { return curr ? curr->elmt : NULL; }
404 RelativeDistinguishedName *Next() const { return curr && curr->next ? curr->next->elmt : NULL; }
405 RelativeDistinguishedName *Prev() const { return curr && curr->prev ? curr->prev->elmt : NULL; }
406
407 // routines that move the curr elmt
408 RelativeDistinguishedName *GoNext() { if (curr) curr = curr->next; return Curr(); }
409 RelativeDistinguishedName *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
410
411 // write & alloc fcns - returns new elmt
412 RelativeDistinguishedName *Append(); // add elmt to end of list
413 RelativeDistinguishedName *Prepend(); // add elmt to beginning of list
414 RelativeDistinguishedName *InsertBefore(); //insert elmt before current elmt
415 RelativeDistinguishedName *InsertAfter(); //insert elmt after current elmt
416
417 // write & alloc & copy - returns list after copying elmt
418 RDNSequence &AppendCopy (RelativeDistinguishedName &elmt); // add elmt to end of list
419 RDNSequence &PrependCopy (RelativeDistinguishedName &elmt); // add elmt to beginning of list
420 RDNSequence &InsertBeforeAndCopy (RelativeDistinguishedName &elmt); //insert elmt before current elmt
421 RDNSequence &InsertAfterAndCopy (RelativeDistinguishedName &elmt); //insert elmt after current elmt
422
423 // removing the current elmt from the list
424 void RemoveCurrFromList();
425
426 // encode and decode routines
427 AsnLen BEnc (BUF_TYPE b);
428 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
429 AsnLen BEncContent (BUF_TYPE b);
430 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
431
432 PDU_MEMBER_MACROS
433 void Print (ostream &os) const;
434};
435
436
437class Attributes: public AsnType
438{
439protected:
440 unsigned long int count;
441 struct AsnListElmt
442 {
443 AsnListElmt *next;
444 AsnListElmt *prev;
445 Attribute *elmt;
446 } *first, *curr, *last;
447
448public:
449 Attributes() { count = 0; first = curr = last = NULL; }
450 Attributes (const Attributes &);
451 virtual ~Attributes();
452 virtual AsnType *Clone() const;
453
454 virtual AsnType *Copy() const;
455
456 Attributes &operator = (const Attributes &);
457 void SetCurrElmt (unsigned long int index);
458 unsigned long int GetCurrElmtIndex();
459 void SetCurrToFirst() { curr = first; }
460 void SetCurrToLast() { curr = last; }
461 // reading member fcns
462 int Count() const { return count; }
463 // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
464 Attribute *First() const { return count > 0 ? first->elmt : NULL; }
465 Attribute *Last() const { return count > 0 ? last->elmt : NULL; }
466 Attribute *Curr() const { return curr ? curr->elmt : NULL; }
467 Attribute *Next() const { return curr && curr->next ? curr->next->elmt : NULL; }
468 Attribute *Prev() const { return curr && curr->prev ? curr->prev->elmt : NULL; }
469
470 // routines that move the curr elmt
471 Attribute *GoNext() { if (curr) curr = curr->next; return Curr(); }
472 Attribute *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
473
474 // write & alloc fcns - returns new elmt
475 Attribute *Append(); // add elmt to end of list
476 Attribute *Prepend(); // add elmt to beginning of list
477 Attribute *InsertBefore(); //insert elmt before current elmt
478 Attribute *InsertAfter(); //insert elmt after current elmt
479
480 // write & alloc & copy - returns list after copying elmt
481 Attributes &AppendCopy (Attribute &elmt); // add elmt to end of list
482 Attributes &PrependCopy (Attribute &elmt); // add elmt to beginning of list
483 Attributes &InsertBeforeAndCopy (Attribute &elmt); //insert elmt before current elmt
484 Attributes &InsertAfterAndCopy (Attribute &elmt); //insert elmt after current elmt
485
486 // removing the current elmt from the list
487 void RemoveCurrFromList();
488
489 // encode and decode routines
490 AsnLen BEnc (BUF_TYPE b);
491 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
492 AsnLen BEncContent (BUF_TYPE b);
493 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
494
495 PDU_MEMBER_MACROS
496 void Print (ostream &os) const;
497};
498
499
500class Name: public AsnType
501{
502public:
503 enum ChoiceIdEnum
504 {
505 rDNSequenceCid = 0
506 };
507
508 enum ChoiceIdEnum choiceId;
509 union
510 {
511 RDNSequence *rDNSequence;
512 };
513
514
515 Name();
516 Name (const Name &);
517 virtual ~Name();
518
519 virtual AsnType *Clone() const;
520
521 virtual AsnType *Copy() const;
522
523 Name &operator = (const Name &);
524 AsnLen BEncContent (BUF_TYPE b);
525 void BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
526 AsnLen BEnc (BUF_TYPE b);
527 void BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
528 int BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded);
529 int BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded);
530
531 void Print (ostream &os) const;
532};
533
534
535/* RDNSequence */
536typedef RDNSequence DistinguishedName;
537
538//------------------------------------------------------------------------------
539// externs for value defs
540
541//------------------------------------------------------------------------------
542
543#endif /* conditional include of sm_x501if.h */
mirror of Security