package org.apache.commons.ssl.asn1;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Vector;
public abstract class ASN1Sequence
extends ASN1Object {
private Vector seq = new Vector();
/**
* return an ASN1Sequence from the given object.
*
* @param obj the object we want converted.
* @throws IllegalArgumentException if the object cannot be converted.
*/
public static ASN1Sequence getInstance(
Object obj) {
if (obj == null || obj instanceof ASN1Sequence) {
return (ASN1Sequence) obj;
}
throw new IllegalArgumentException("unknown object in getInstance");
}
/**
* Return an ASN1 sequence from a tagged object. There is a special
* case here, if an object appears to have been explicitly tagged on
* reading but we were expecting it to be implictly tagged in the
* normal course of events it indicates that we lost the surrounding
* sequence - so we need to add it back (this will happen if the tagged
* object is a sequence that contains other sequences). If you are
* dealing with implicitly tagged sequences you really <b>should</b>
* be using this method.
*
* @param obj the tagged object.
* @param explicit true if the object is meant to be explicitly tagged,
* false otherwise.
* @throws IllegalArgumentException if the tagged object cannot
* be converted.
*/
public static ASN1Sequence getInstance(
ASN1TaggedObject obj,
boolean explicit) {
if (explicit) {
if (!obj.isExplicit()) {
throw new IllegalArgumentException("object implicit - explicit expected.");
}
return (ASN1Sequence) obj.getObject();
} else {
//
// constructed object which appears to be explicitly tagged
// when it should be implicit means we have to add the
// surrounding sequence.
//
if (obj.isExplicit()) {
if (obj instanceof BERTaggedObject) {
return new BERSequence(obj.getObject());
} else {
return new DERSequence(obj.getObject());
}
} else {
if (obj.getObject() instanceof ASN1Sequence) {
return (ASN1Sequence) obj.getObject();
}
}
}
throw new IllegalArgumentException(
"unknown object in getInstanceFromTagged");
}
public Enumeration getObjects() {
return seq.elements();
}
public ASN1SequenceParser parser() {
final ASN1Sequence outer = this;
return new ASN1SequenceParser() {
private final int max = size();
private int index;
public DEREncodable readObject() throws IOException {
if (index == max) {
return null;
}
DEREncodable obj = getObjectAt(index++);
if (obj instanceof ASN1Sequence) {
return ((ASN1Sequence) obj).parser();
}
if (obj instanceof ASN1Set) {
return ((ASN1Set) obj).parser();
}
return obj;
}
public DERObject getDERObject() {
return outer;
}
};
}
/**
* return the object at the sequence postion indicated by index.
*
* @param index the sequence number (starting at zero) of the object
* @return the object at the sequence postion indicated by index.
*/
public DEREncodable getObjectAt(
int index) {
return (DEREncodable) seq.elementAt(index);
}
/**
* return the number of objects in this sequence.
*
* @return the number of objects in this sequence.
*/
public int size() {
return seq.size();
}
public int hashCode() {
Enumeration e = this.getObjects();
int hashCode = 0;
while (e.hasMoreElements()) {
Object o = e.nextElement();
if (o != null) {
hashCode ^= o.hashCode();
}
}
return hashCode;
}
boolean asn1Equals(
DERObject o) {
if (!(o instanceof ASN1Sequence)) {
return false;
}
ASN1Sequence other = (ASN1Sequence) o;
if (this.size() != other.size()) {
return false;
}
Enumeration s1 = this.getObjects();
Enumeration s2 = other.getObjects();
while (s1.hasMoreElements()) {
DERObject o1 = ((DEREncodable) s1.nextElement()).getDERObject();
DERObject o2 = ((DEREncodable) s2.nextElement()).getDERObject();
if (o1 == o2 || (o1 != null && o1.equals(o2))) {
continue;
}
return false;
}
return true;
}
protected void addObject(
DEREncodable obj) {
seq.addElement(obj);
}
abstract void encode(DEROutputStream out)
throws IOException;
public String toString() {
return seq.toString();
}
}