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 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
  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   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
 131 class AttributeTypeAndDistinguishedValueSetOf: public AsnType
 132 {
 133 protected:
 134   unsigned long int     count;
 135   struct AsnListElmt
 136   {
 137     AsnListElmt *next;
 138     AsnListElmt *prev;
 139     AttributeTypeAndDistinguishedValueSetOfSeq  *elmt;
 140   }                     *first, *curr, *last;
 141
 142 public:
 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
 194 class AttributeSetOf: public AsnType
 195 {
 196 protected:
 197   unsigned long int     count;
 198   struct AsnListElmt
 199   {
 200     AsnListElmt *next;
 201     AsnListElmt *prev;
 202     AttributeValue      *elmt;
 203   }                     *first, *curr, *last;
 204
 205 public:
 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
 257 class Attribute: public AsnType
 258 {
 259 public:
 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
 283 class AttributeTypeAndDistinguishedValue: public AsnType
 284 {
 285 public:
 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
 311 class RelativeDistinguishedName: public AsnType
 312 {
 313 protected:
 314   unsigned long int     count;
 315   struct AsnListElmt
 316   {
 317     AsnListElmt *next;
 318     AsnListElmt *prev;
 319     AttributeTypeAndDistinguishedValue  *elmt;
 320   }                     *first, *curr, *last;
 321
 322 public:
 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
 374 class RDNSequence: public AsnType
 375 {
 376 protected:
 377   unsigned long int     count;
 378   struct AsnListElmt
 379   {
 380     AsnListElmt *next;
 381     AsnListElmt *prev;
 382     RelativeDistinguishedName   *elmt;
 383   }                     *first, *curr, *last;
 384
 385 public:
 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
 437 class Attributes: public AsnType
 438 {
 439 protected:
 440   unsigned long int     count;
 441   struct AsnListElmt
 442   {
 443     AsnListElmt *next;
 444     AsnListElmt *prev;
 445     Attribute   *elmt;
 446   }                     *first, *curr, *last;
 447
 448 public:
 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
 500 class Name: public AsnType
 501 {
 502 public:
 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 */
 536 typedef RDNSequence DistinguishedName;
 537
 538 //------------------------------------------------------------------------------
 539 // externs for value defs
 540
 541 //------------------------------------------------------------------------------
 542
 543 #endif /* conditional include of sm_x501if.h */