ASN1Sequence


1   /**
2    *  Licensed to the Apache Software Foundation (ASF) under one or more
3    *  contributor license agreements.  See the NOTICE file distributed with
4    *  this work for additional information regarding copyright ownership.
5    *  The ASF licenses this file to You under the Apache License, Version 2.0
6    *  (the "License"); you may not use this file except in compliance with
7    *  the License.  You may obtain a copy of the License at
8    *
9    *     http://www.apache.org/licenses/LICENSE-2.0
10   *
11   *  Unless required by applicable law or agreed to in writing, software
12   *  distributed under the License is distributed on an "AS IS" BASIS,
13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   *  See the License for the specific language governing permissions and
15   *  limitations under the License.
16   */
17  
18  package org.apache.geronimo.util.asn1;
19  
20  import java.io.IOException  ;
21  import java.util.Enumeration  ;
22  import java.util.Vector  ;
23  
24  public abstract class ASN1Sequence
25      extends DERObject
26  {
27      private Vector   seq = new Vector  ();
28  
29      /**
30       * return an ASN1Sequence from the given object.
31       *
32       * @param obj the object we want converted.
33       * @exception IllegalArgumentException if the object cannot be converted.
34       */
35      public static ASN1Sequence getInstance(
36          Object    obj)
37      {
38          if (obj == null || obj instanceof ASN1Sequence)
39          {
40              return (ASN1Sequence)obj;
41          }
42  
43          throw new IllegalArgumentException  ("unknown object in getInstance");
44      }
45  
46      /**
47       * Return an ASN1 sequence from a tagged object. There is a special
48       * case here, if an object appears to have been explicitly tagged on
49       * reading but we were expecting it to be implictly tagged in the
50       * normal course of events it indicates that we lost the surrounding
51       * sequence - so we need to add it back (this will happen if the tagged
52       * object is a sequence that contains other sequences). If you are
53       * dealing with implicitly tagged sequences you really <b>should</b>
54       * be using this method.
55       *
56       * @param obj the tagged object.
57       * @param explicit true if the object is meant to be explicitly tagged,
58       *          false otherwise.
59       * @exception IllegalArgumentException if the tagged object cannot
60       *          be converted.
61       */
62      public static ASN1Sequence getInstance(
63          ASN1TaggedObject    obj,
64          boolean             explicit)
65      {
66          if (explicit)
67          {
68              if (!obj.isExplicit())
69              {
70                  throw new IllegalArgumentException  ("object implicit - explicit expected.");
71              }
72  
73              return (ASN1Sequence)obj.getObject();
74          }
75          else
76          {
77              //
78              // constructed object which appears to be explicitly tagged
79              // when it should be implicit means we have to add the
80              // surrounding sequence.
81              //
82              if (obj.isExplicit())
83              {
84                  if (obj instanceof BERTaggedObject)
85                  {
86                      return new BERSequence(obj.getObject());
87                  }
88                  else
89                  {
90                      return new DERSequence(obj.getObject());
91                  }
92              }
93              else
94              {
95                  if (obj.getObject() instanceof ASN1Sequence)
96                  {
97                      return (ASN1Sequence)obj.getObject();
98                  }
99              }
100         }
101 
102         throw new IllegalArgumentException  (
103                 "unknown object in getInstanceFromTagged");
104     }
105 
106     public Enumeration   getObjects()
107     {
108         return seq.elements();
109     }
110 
111     /**
112      * return the object at the sequence postion indicated by index.
113      *
114      * @param index the sequence number (starting at zero) of the object
115      * @return the object at the sequence postion indicated by index.
116      */
117     public DEREncodable getObjectAt(
118         int index)
119     {
120         return (DEREncodable)seq.elementAt(index);
121     }
122 
123     /**
124      * return the number of objects in this sequence.
125      *
126      * @return the number of objects in this sequence.
127      */
128     public int size()
129     {
130         return seq.size();
131     }
132 
133     public int hashCode()
134     {
135         Enumeration               e = this.getObjects();
136         int                     hashCode = 0;
137 
138         while (e.hasMoreElements())
139         {
140             Object      o = e.nextElement();
141 
142             if (o != null)
143             {
144                 hashCode ^= o.hashCode();
145             }
146         }
147 
148         return hashCode;
149     }
150 
151     public boolean equals(
152         Object    o)
153     {
154         if (o == null || !(o instanceof ASN1Sequence))
155         {
156             return false;
157         }
158 
159         ASN1Sequence   other = (ASN1Sequence)o;
160 
161         if (this.size() != other.size())
162         {
163             return false;
164         }
165 
166         Enumeration   s1 = this.getObjects();
167         Enumeration   s2 = other.getObjects();
168 
169         while (s1.hasMoreElements())
170         {
171             Object    o1 = s1.nextElement();
172             Object    o2 = s2.nextElement();
173 
174             if (o1 != null && o2 != null)
175             {
176                 if (!o1.equals(o2))
177                 {
178                     return false;
179                 }
180             }
181             else if (o1 == null && o2 == null)
182             {
183                 continue;
184             }
185             else
186             {
187                 return false;
188             }
189         }
190 
191         return true;
192     }
193 
194     protected void addObject(
195         DEREncodable obj)
196     {
197         seq.addElement(obj);
198     }
199 
200     abstract void encode(DEROutputStream out)
201         throws IOException  ;
202 }
203
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags