content: package local.org.bouncycastle.asn1.x509;
  
  import local.org.bouncycastle.asn1.ASN1Encodable;
  import local.org.bouncycastle.asn1.ASN1EncodableVector;
  import local.org.bouncycastle.asn1.ASN1Integer;
  import local.org.bouncycastle.asn1.ASN1Object;
  import local.org.bouncycastle.asn1.ASN1Primitive;
  import local.org.bouncycastle.asn1.ASN1Sequence;
  import local.org.bouncycastle.asn1.ASN1TaggedObject;
  import local.org.bouncycastle.asn1.DERBitString;
  import local.org.bouncycastle.asn1.DERSequence;
  
  public class AttributeCertificateInfo
      extends ASN1Object
  {
      private ASN1Integer              version;
      private Holder                  holder;
      private AttCertIssuer           issuer;
      private AlgorithmIdentifier     signature;
      private ASN1Integer              serialNumber;
      private AttCertValidityPeriod   attrCertValidityPeriod;
      private ASN1Sequence            attributes;
      private DERBitString            issuerUniqueID;
      private Extensions              extensions;
  
      public static AttributeCertificateInfo getInstance(
          ASN1TaggedObject obj,
          boolean          explicit)
      {
          return getInstance(ASN1Sequence.getInstance(obj, explicit));
      }
  
      public static AttributeCertificateInfo getInstance(
          Object  obj)
      {
          if (obj instanceof AttributeCertificateInfo)
          {
              return (AttributeCertificateInfo)obj;
          }
          else if (obj != null)
          {
              return new AttributeCertificateInfo(ASN1Sequence.getInstance(obj));
          }
  
          return null;
      }
  
      private AttributeCertificateInfo(
          ASN1Sequence   seq)
      {
          if (seq.size() < 7 || seq.size() > 9)
          {
              throw new IllegalArgumentException("Bad sequence size: " + seq.size());
          }
  
          this.version = ASN1Integer.getInstance(seq.getObjectAt(0));
          this.holder = Holder.getInstance(seq.getObjectAt(1));
          this.issuer = AttCertIssuer.getInstance(seq.getObjectAt(2));
          this.signature = AlgorithmIdentifier.getInstance(seq.getObjectAt(3));
          this.serialNumber = ASN1Integer.getInstance(seq.getObjectAt(4));
          this.attrCertValidityPeriod = AttCertValidityPeriod.getInstance(seq.getObjectAt(5));
          this.attributes = ASN1Sequence.getInstance(seq.getObjectAt(6));
          
          for (int i = 7; i < seq.size(); i++)
          {
              ASN1Encodable    obj = (ASN1Encodable)seq.getObjectAt(i);
  
              if (obj instanceof DERBitString)
              {
                  this.issuerUniqueID = DERBitString.getInstance(seq.getObjectAt(i));
              }
              else if (obj instanceof ASN1Sequence || obj instanceof Extensions)
              {
                  this.extensions = Extensions.getInstance(seq.getObjectAt(i));
              }
          }
      }
      
      public ASN1Integer getVersion()
      {
          return version;
      }
  
      public Holder getHolder()
      {
          return holder;
      }
  
      public AttCertIssuer getIssuer()
      {
          return issuer;
      }
  
      public AlgorithmIdentifier getSignature()
      {
          return signature;
      }
  
      public ASN1Integer getSerialNumber()
      {
          return serialNumber;
      }
  
      public AttCertValidityPeriod getAttrCertValidityPeriod()
      {
          return attrCertValidityPeriod;
      }
  
      public ASN1Sequence getAttributes()
      {
          return attributes;
      }
  
      public DERBitString getIssuerUniqueID()
      {
          return issuerUniqueID;
      }
  
      public Extensions getExtensions()
      {
          return extensions;
      }
  
      /**
       * Produce an object suitable for an ASN1OutputStream.
       * <pre>
       *  AttributeCertificateInfo ::= SEQUENCE {
       *       version              AttCertVersion -- version is v2,
       *       holder               Holder,
       *       issuer               AttCertIssuer,
       *       signature            AlgorithmIdentifier,
       *       serialNumber         CertificateSerialNumber,
       *       attrCertValidityPeriod   AttCertValidityPeriod,
       *       attributes           SEQUENCE OF Attribute,
       *       issuerUniqueID       UniqueIdentifier OPTIONAL,
       *       extensions           Extensions OPTIONAL
       *  }
       *
       *  AttCertVersion ::= INTEGER { v2(1) }
       * </pre>
       */
      public ASN1Primitive toASN1Primitive()
      {
          ASN1EncodableVector  v = new ASN1EncodableVector();
  
          v.add(version);
          v.add(holder);
          v.add(issuer);
          v.add(signature);
          v.add(serialNumber);
          v.add(attrCertValidityPeriod);
          v.add(attributes);
          
          if (issuerUniqueID != null)
          {
              v.add(issuerUniqueID);
          }
          
          if (extensions != null)
          {
              v.add(extensions);
          }
          
          return new DERSequence(v);
      }
  }
  