SecurityASN1/inc/sm_x501if.h

   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 Mon Apr 22 22:34:19 2002
   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
  16 class AttributeTypeAndDistinguishedValueSetOfSeqSetOf;
  17 class AttributeTypeAndDistinguishedValueSetOfSeq;
  18 class AttributeTypeAndDistinguishedValueSetOf;
  19 class AttributeSetOf;
  20 class Attribute;
  21 class AttributeTypeAndDistinguishedValue;
  22 class RelativeDistinguishedName;
  23 class RDNSequence;
  24 class Attributes;
  25 class Name;
  26
  27 //------------------------------------------------------------------------------
  28 // class definitions:
  29
  30 typedef enum InformationFrameworkAnyId
  31 {
  32
  33 } InformationFrameworkAnyId;
  34
  35
  36 /* OBJECT IDENTIFIER */
  37 typedef AsnOid AttributeType;
  38
  39 /* ANY */
  40 typedef AsnAny AttributeValue;
  41
  42 class AttributeTypeAndDistinguishedValueSetOfSeqSetOf: public AsnType
  43 {
  44 protected:
  45   unsigned long int     count;
  46   struct AsnListElmt
  47   {
  48     AsnListElmt *next;
  49     AsnListElmt *prev;
  50     AsnAny      *elmt;
  51   }                     *first, *curr, *last;
  52
  53 public:
  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
 105 class AttributeTypeAndDistinguishedValueSetOfSeq: public AsnType
 106 {
 107 public:
 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   void          Print (ostream &os) const;
 125 };
 126
 127
 128 class AttributeTypeAndDistinguishedValueSetOf: public AsnType
 129 {
 130 protected:
 131   unsigned long int     count;
 132   struct AsnListElmt
 133   {
 134     AsnListElmt *next;
 135     AsnListElmt *prev;
 136     AttributeTypeAndDistinguishedValueSetOfSeq  *elmt;
 137   }                     *first, *curr, *last;
 138
 139 public:
 140                         AttributeTypeAndDistinguishedValueSetOf() { count = 0; first = curr = last = NULL; }
 141                         AttributeTypeAndDistinguishedValueSetOf (const AttributeTypeAndDistinguishedValueSetOf &);
 142   virtual               ~AttributeTypeAndDistinguishedValueSetOf();
 143   virtual AsnType       *Clone() const;
 144
 145   virtual AsnType       *Copy() const;
 146
 147   AttributeTypeAndDistinguishedValueSetOf               &operator = (const AttributeTypeAndDistinguishedValueSetOf &);
 148   void          SetCurrElmt (unsigned long int index);
 149   unsigned long int     GetCurrElmtIndex();
 150   void          SetCurrToFirst() { curr = first; }
 151   void          SetCurrToLast()  { curr = last; }
 152   // reading member fcns
 153   int                   Count() const   { return count; }
 154   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 155   AttributeTypeAndDistinguishedValueSetOfSeq    *First() const  { return count > 0 ? first->elmt : NULL; }
 156   AttributeTypeAndDistinguishedValueSetOfSeq    *Last() const   { return count > 0 ? last->elmt : NULL; }
 157   AttributeTypeAndDistinguishedValueSetOfSeq    *Curr() const   { return curr ? curr->elmt : NULL; }
 158   AttributeTypeAndDistinguishedValueSetOfSeq    *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 159   AttributeTypeAndDistinguishedValueSetOfSeq    *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 160
 161   // routines that move the curr elmt
 162   AttributeTypeAndDistinguishedValueSetOfSeq    *GoNext() { if (curr) curr = curr->next; return Curr(); }
 163   AttributeTypeAndDistinguishedValueSetOfSeq    *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 164
 165   // write & alloc fcns - returns new elmt
 166   AttributeTypeAndDistinguishedValueSetOfSeq    *Append();  // add elmt to end of list
 167   AttributeTypeAndDistinguishedValueSetOfSeq    *Prepend(); // add elmt to beginning of list
 168   AttributeTypeAndDistinguishedValueSetOfSeq    *InsertBefore(); //insert elmt before current elmt
 169   AttributeTypeAndDistinguishedValueSetOfSeq    *InsertAfter(); //insert elmt after current elmt
 170
 171   // write & alloc & copy - returns list after copying elmt
 172   AttributeTypeAndDistinguishedValueSetOf       &AppendCopy (AttributeTypeAndDistinguishedValueSetOfSeq &elmt);  // add elmt to end of list
 173   AttributeTypeAndDistinguishedValueSetOf       &PrependCopy (AttributeTypeAndDistinguishedValueSetOfSeq &elmt); // add elmt to beginning of list
 174   AttributeTypeAndDistinguishedValueSetOf       &InsertBeforeAndCopy (AttributeTypeAndDistinguishedValueSetOfSeq &elmt); //insert elmt before current elmt
 175   AttributeTypeAndDistinguishedValueSetOf       &InsertAfterAndCopy (AttributeTypeAndDistinguishedValueSetOfSeq &elmt); //insert elmt after current elmt
 176
 177   // removing the current elmt from the list
 178   void          RemoveCurrFromList();
 179
 180   // encode and decode routines
 181   AsnLen                BEnc (BUF_TYPE b);
 182   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 183   AsnLen                BEncContent (BUF_TYPE b);
 184   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 185
 186   PDU_MEMBER_MACROS
 187   void          Print (ostream &os) const;
 188 };
 189
 190
 191 class AttributeSetOf: public AsnType
 192 {
 193 protected:
 194   unsigned long int     count;
 195   struct AsnListElmt
 196   {
 197     AsnListElmt *next;
 198     AsnListElmt *prev;
 199     AttributeValue      *elmt;
 200   }                     *first, *curr, *last;
 201
 202 public:
 203                         AttributeSetOf() { count = 0; first = curr = last = NULL; }
 204                         AttributeSetOf (const AttributeSetOf &);
 205   virtual               ~AttributeSetOf();
 206   virtual AsnType       *Clone() const;
 207
 208   virtual AsnType       *Copy() const;
 209
 210   AttributeSetOf                &operator = (const AttributeSetOf &);
 211   void          SetCurrElmt (unsigned long int index);
 212   unsigned long int     GetCurrElmtIndex();
 213   void          SetCurrToFirst() { curr = first; }
 214   void          SetCurrToLast()  { curr = last; }
 215   // reading member fcns
 216   int                   Count() const   { return count; }
 217   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 218   AttributeValue        *First() const  { return count > 0 ? first->elmt : NULL; }
 219   AttributeValue        *Last() const   { return count > 0 ? last->elmt : NULL; }
 220   AttributeValue        *Curr() const   { return curr ? curr->elmt : NULL; }
 221   AttributeValue        *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 222   AttributeValue        *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 223
 224   // routines that move the curr elmt
 225   AttributeValue        *GoNext() { if (curr) curr = curr->next; return Curr(); }
 226   AttributeValue        *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 227
 228   // write & alloc fcns - returns new elmt
 229   AttributeValue        *Append();  // add elmt to end of list
 230   AttributeValue        *Prepend(); // add elmt to beginning of list
 231   AttributeValue        *InsertBefore(); //insert elmt before current elmt
 232   AttributeValue        *InsertAfter(); //insert elmt after current elmt
 233
 234   // write & alloc & copy - returns list after copying elmt
 235   AttributeSetOf        &AppendCopy (AttributeValue &elmt);  // add elmt to end of list
 236   AttributeSetOf        &PrependCopy (AttributeValue &elmt); // add elmt to beginning of list
 237   AttributeSetOf        &InsertBeforeAndCopy (AttributeValue &elmt); //insert elmt before current elmt
 238   AttributeSetOf        &InsertAfterAndCopy (AttributeValue &elmt); //insert elmt after current elmt
 239
 240   // removing the current elmt from the list
 241   void          RemoveCurrFromList();
 242
 243   // encode and decode routines
 244   AsnLen                BEnc (BUF_TYPE b);
 245   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 246   AsnLen                BEncContent (BUF_TYPE b);
 247   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 248
 249   PDU_MEMBER_MACROS
 250   void          Print (ostream &os) const;
 251 };
 252
 253
 254 class Attribute: public AsnType
 255 {
 256 public:
 257   AttributeType         type;
 258   AttributeSetOf                values;
 259
 260                         Attribute();
 261                         Attribute (const Attribute &);
 262   virtual               ~Attribute();
 263   virtual AsnType       *Clone() const;
 264
 265   virtual AsnType       *Copy() const;
 266
 267   Attribute             &operator = (const Attribute &);
 268   AsnLen                BEncContent (BUF_TYPE b);
 269   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 270
 271   AsnLen                BEnc (BUF_TYPE b);
 272   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 273   void          Print (ostream &os) const;
 274 };
 275
 276
 277 class AttributeTypeAndDistinguishedValue: public AsnType
 278 {
 279 public:
 280   AsnOid                type;
 281   AsnAny                value;
 282   AsnBool               *primaryDistinguished;
 283   AttributeTypeAndDistinguishedValueSetOf               *valuesWithContext;
 284
 285                         AttributeTypeAndDistinguishedValue();
 286                         AttributeTypeAndDistinguishedValue (const AttributeTypeAndDistinguishedValue &);
 287   virtual               ~AttributeTypeAndDistinguishedValue();
 288   virtual AsnType       *Clone() const;
 289
 290   virtual AsnType       *Copy() const;
 291
 292   AttributeTypeAndDistinguishedValue            &operator = (const AttributeTypeAndDistinguishedValue &);
 293   AsnLen                BEncContent (BUF_TYPE b);
 294   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 295
 296   AsnLen                BEnc (BUF_TYPE b);
 297   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 298   void          Print (ostream &os) const;
 299 };
 300
 301
 302 class RelativeDistinguishedName: public AsnType
 303 {
 304 protected:
 305   unsigned long int     count;
 306   struct AsnListElmt
 307   {
 308     AsnListElmt *next;
 309     AsnListElmt *prev;
 310     AttributeTypeAndDistinguishedValue  *elmt;
 311   }                     *first, *curr, *last;
 312
 313 public:
 314                         RelativeDistinguishedName() { count = 0; first = curr = last = NULL; }
 315                         RelativeDistinguishedName (const RelativeDistinguishedName &);
 316   virtual               ~RelativeDistinguishedName();
 317   virtual AsnType       *Clone() const;
 318
 319   virtual AsnType       *Copy() const;
 320
 321   RelativeDistinguishedName             &operator = (const RelativeDistinguishedName &);
 322   void          SetCurrElmt (unsigned long int index);
 323   unsigned long int     GetCurrElmtIndex();
 324   void          SetCurrToFirst() { curr = first; }
 325   void          SetCurrToLast()  { curr = last; }
 326   // reading member fcns
 327   int                   Count() const   { return count; }
 328   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 329   AttributeTypeAndDistinguishedValue    *First() const  { return count > 0 ? first->elmt : NULL; }
 330   AttributeTypeAndDistinguishedValue    *Last() const   { return count > 0 ? last->elmt : NULL; }
 331   AttributeTypeAndDistinguishedValue    *Curr() const   { return curr ? curr->elmt : NULL; }
 332   AttributeTypeAndDistinguishedValue    *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 333   AttributeTypeAndDistinguishedValue    *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 334
 335   // routines that move the curr elmt
 336   AttributeTypeAndDistinguishedValue    *GoNext() { if (curr) curr = curr->next; return Curr(); }
 337   AttributeTypeAndDistinguishedValue    *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 338
 339   // write & alloc fcns - returns new elmt
 340   AttributeTypeAndDistinguishedValue    *Append();  // add elmt to end of list
 341   AttributeTypeAndDistinguishedValue    *Prepend(); // add elmt to beginning of list
 342   AttributeTypeAndDistinguishedValue    *InsertBefore(); //insert elmt before current elmt
 343   AttributeTypeAndDistinguishedValue    *InsertAfter(); //insert elmt after current elmt
 344
 345   // write & alloc & copy - returns list after copying elmt
 346   RelativeDistinguishedName     &AppendCopy (AttributeTypeAndDistinguishedValue &elmt);  // add elmt to end of list
 347   RelativeDistinguishedName     &PrependCopy (AttributeTypeAndDistinguishedValue &elmt); // add elmt to beginning of list
 348   RelativeDistinguishedName     &InsertBeforeAndCopy (AttributeTypeAndDistinguishedValue &elmt); //insert elmt before current elmt
 349   RelativeDistinguishedName     &InsertAfterAndCopy (AttributeTypeAndDistinguishedValue &elmt); //insert elmt after current elmt
 350
 351   // removing the current elmt from the list
 352   void          RemoveCurrFromList();
 353
 354   // encode and decode routines
 355   AsnLen                BEnc (BUF_TYPE b);
 356   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 357   AsnLen                BEncContent (BUF_TYPE b);
 358   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 359
 360   PDU_MEMBER_MACROS
 361   void          Print (ostream &os) const;
 362 };
 363
 364
 365 class RDNSequence: public AsnType
 366 {
 367 protected:
 368   unsigned long int     count;
 369   struct AsnListElmt
 370   {
 371     AsnListElmt *next;
 372     AsnListElmt *prev;
 373     RelativeDistinguishedName   *elmt;
 374   }                     *first, *curr, *last;
 375
 376 public:
 377                         RDNSequence() { count = 0; first = curr = last = NULL; }
 378                         RDNSequence (const RDNSequence &);
 379   virtual               ~RDNSequence();
 380   virtual AsnType       *Clone() const;
 381
 382   virtual AsnType       *Copy() const;
 383
 384   RDNSequence           &operator = (const RDNSequence &);
 385   void          SetCurrElmt (unsigned long int index);
 386   unsigned long int     GetCurrElmtIndex();
 387   void          SetCurrToFirst() { curr = first; }
 388   void          SetCurrToLast()  { curr = last; }
 389   // reading member fcns
 390   int                   Count() const   { return count; }
 391   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 392   RelativeDistinguishedName     *First() const  { return count > 0 ? first->elmt : NULL; }
 393   RelativeDistinguishedName     *Last() const   { return count > 0 ? last->elmt : NULL; }
 394   RelativeDistinguishedName     *Curr() const   { return curr ? curr->elmt : NULL; }
 395   RelativeDistinguishedName     *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 396   RelativeDistinguishedName     *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 397
 398   // routines that move the curr elmt
 399   RelativeDistinguishedName     *GoNext() { if (curr) curr = curr->next; return Curr(); }
 400   RelativeDistinguishedName     *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 401
 402   // write & alloc fcns - returns new elmt
 403   RelativeDistinguishedName     *Append();  // add elmt to end of list
 404   RelativeDistinguishedName     *Prepend(); // add elmt to beginning of list
 405   RelativeDistinguishedName     *InsertBefore(); //insert elmt before current elmt
 406   RelativeDistinguishedName     *InsertAfter(); //insert elmt after current elmt
 407
 408   // write & alloc & copy - returns list after copying elmt
 409   RDNSequence   &AppendCopy (RelativeDistinguishedName &elmt);  // add elmt to end of list
 410   RDNSequence   &PrependCopy (RelativeDistinguishedName &elmt); // add elmt to beginning of list
 411   RDNSequence   &InsertBeforeAndCopy (RelativeDistinguishedName &elmt); //insert elmt before current elmt
 412   RDNSequence   &InsertAfterAndCopy (RelativeDistinguishedName &elmt); //insert elmt after current elmt
 413
 414   // removing the current elmt from the list
 415   void          RemoveCurrFromList();
 416
 417   // encode and decode routines
 418   AsnLen                BEnc (BUF_TYPE b);
 419   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 420   AsnLen                BEncContent (BUF_TYPE b);
 421   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 422
 423   PDU_MEMBER_MACROS
 424   void          Print (ostream &os) const;
 425 };
 426
 427
 428 class Attributes: public AsnType
 429 {
 430 protected:
 431   unsigned long int     count;
 432   struct AsnListElmt
 433   {
 434     AsnListElmt *next;
 435     AsnListElmt *prev;
 436     Attribute   *elmt;
 437   }                     *first, *curr, *last;
 438
 439 public:
 440                         Attributes() { count = 0; first = curr = last = NULL; }
 441                         Attributes (const Attributes &);
 442   virtual               ~Attributes();
 443   virtual AsnType       *Clone() const;
 444
 445   virtual AsnType       *Copy() const;
 446
 447   Attributes            &operator = (const Attributes &);
 448   void          SetCurrElmt (unsigned long int index);
 449   unsigned long int     GetCurrElmtIndex();
 450   void          SetCurrToFirst() { curr = first; }
 451   void          SetCurrToLast()  { curr = last; }
 452   // reading member fcns
 453   int                   Count() const   { return count; }
 454   // NOTE: if your compiler complains about these NULLs, its definition of NULL is broken (and you better change it there!)
 455   Attribute     *First() const  { return count > 0 ? first->elmt : NULL; }
 456   Attribute     *Last() const   { return count > 0 ? last->elmt : NULL; }
 457   Attribute     *Curr() const   { return curr ? curr->elmt : NULL; }
 458   Attribute     *Next() const   { return curr && curr->next ? curr->next->elmt : NULL; }
 459   Attribute     *Prev() const   { return curr && curr->prev ? curr->prev->elmt : NULL; }
 460
 461   // routines that move the curr elmt
 462   Attribute     *GoNext() { if (curr) curr = curr->next; return Curr(); }
 463   Attribute     *GoPrev() { if (curr) curr = curr->prev; return Curr(); }
 464
 465   // write & alloc fcns - returns new elmt
 466   Attribute     *Append();  // add elmt to end of list
 467   Attribute     *Prepend(); // add elmt to beginning of list
 468   Attribute     *InsertBefore(); //insert elmt before current elmt
 469   Attribute     *InsertAfter(); //insert elmt after current elmt
 470
 471   // write & alloc & copy - returns list after copying elmt
 472   Attributes    &AppendCopy (Attribute &elmt);  // add elmt to end of list
 473   Attributes    &PrependCopy (Attribute &elmt); // add elmt to beginning of list
 474   Attributes    &InsertBeforeAndCopy (Attribute &elmt); //insert elmt before current elmt
 475   Attributes    &InsertAfterAndCopy (Attribute &elmt); //insert elmt after current elmt
 476
 477   // removing the current elmt from the list
 478   void          RemoveCurrFromList();
 479
 480   // encode and decode routines
 481   AsnLen                BEnc (BUF_TYPE b);
 482   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 483   AsnLen                BEncContent (BUF_TYPE b);
 484   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 485
 486   PDU_MEMBER_MACROS
 487   void          Print (ostream &os) const;
 488 };
 489
 490
 491 class Name: public AsnType
 492 {
 493 public:
 494   enum ChoiceIdEnum
 495   {
 496      rDNSequenceCid = 0
 497   };
 498
 499   enum ChoiceIdEnum     choiceId;
 500   union
 501   {
 502      RDNSequence                *rDNSequence;
 503   };
 504
 505
 506                         Name();
 507                         Name (const Name &);
 508   virtual               ~Name();
 509
 510   virtual AsnType       *Clone() const;
 511
 512   virtual AsnType       *Copy() const;
 513
 514   Name          &operator = (const Name &);
 515   AsnLen                BEncContent (BUF_TYPE b);
 516   void                  BDecContent (BUF_TYPE b, AsnTag tag, AsnLen elmtLen, AsnLen &bytesDecoded, ENV_TYPE env);
 517   AsnLen                BEnc (BUF_TYPE b);
 518   void                  BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env);
 519   void                  Print (ostream &os) const;
 520 };
 521
 522
 523 /* RDNSequence */
 524 typedef RDNSequence DistinguishedName;
 525
 526 //------------------------------------------------------------------------------
 527 // externs for value defs
 528
 529 //------------------------------------------------------------------------------
 530
 531 #endif /* conditional include of sm_x501if.h */