package org.apache.commons.ssl.asn1;
import java.io.IOException;
/**
* ASN.1 TaggedObject - in ASN.1 nottation this is any object proceeded by
* a [n] where n is some number - these are assume to follow the construction
* rules (as with sequences).
*/
public abstract class ASN1TaggedObject
extends ASN1Object
implements ASN1TaggedObjectParser {
int tagNo;
boolean empty = false;
boolean explicit = true;
DEREncodable obj = null;
static public ASN1TaggedObject getInstance(
ASN1TaggedObject obj,
boolean explicit) {
if (explicit) {
return (ASN1TaggedObject) obj.getObject();
}
throw new IllegalArgumentException("implicitly tagged tagged object");
}
static public ASN1TaggedObject getInstance(
Object obj) {
if (obj == null || obj instanceof ASN1TaggedObject) {
return (ASN1TaggedObject) obj;
}
throw new IllegalArgumentException("unknown object in getInstance");
}
/**
* Create a tagged object in the explicit style.
*
* @param tagNo the tag number for this object.
* @param obj the tagged object.
*/
public ASN1TaggedObject(
int tagNo,
DEREncodable obj) {
this.explicit = true;
this.tagNo = tagNo;
this.obj = obj;
}
/**
* Create a tagged object with the style given by the value of explicit.
* <p>
* If the object implements ASN1Choice the tag style will always be changed
* to explicit in accordance with the ASN.1 encoding rules.
* </p>
*
* @param explicit true if the object is explicitly tagged.
* @param tagNo the tag number for this object.
* @param obj the tagged object.
*/
public ASN1TaggedObject(
boolean explicit,
int tagNo,
DEREncodable obj) {
if (obj instanceof ASN1Choice) {
this.explicit = true;
} else {
this.explicit = explicit;
}
this.tagNo = tagNo;
this.obj = obj;
}
boolean asn1Equals(
DERObject o) {
if (!(o instanceof ASN1TaggedObject)) {
return false;
}
ASN1TaggedObject other = (ASN1TaggedObject) o;
if (tagNo != other.tagNo || empty != other.empty || explicit != other.explicit) {
return false;
}
if (obj == null) {
if (other.obj != null) {
return false;
}
} else {
if (!(obj.getDERObject().equals(other.obj.getDERObject()))) {
return false;
}
}
return true;
}
public int hashCode() {
int code = tagNo;
if (obj != null) {
code ^= obj.hashCode();
}
return code;
}
public int getTagNo() {
return tagNo;
}
/**
* return whether or not the object may be explicitly tagged.
* <p/>
* Note: if the object has been read from an input stream, the only
* time you can be sure if isExplicit is returning the true state of
* affairs is if it returns false. An implicitly tagged object may appear
* to be explicitly tagged, so you need to understand the context under
* which the reading was done as well, see getObject below.
*/
public boolean isExplicit() {
return explicit;
}
public boolean isEmpty() {
return empty;
}
/**
* return whatever was following the tag.
* <p/>
* Note: tagged objects are generally context dependent if you're
* trying to extract a tagged object you should be going via the
* appropriate getInstance method.
*/
public DERObject getObject() {
if (obj != null) {
return obj.getDERObject();
}
return null;
}
/**
* Return the object held in this tagged object as a parser assuming it has
* the type of the passed in tag. If the object doesn't have a parser
* associated with it, the base object is returned.
*/
public DEREncodable getObjectParser(
int tag,
boolean isExplicit) {
switch (tag) {
case DERTags.SET:
return ASN1Set.getInstance(this, isExplicit).parser();
case DERTags.SEQUENCE:
return ASN1Sequence.getInstance(this, isExplicit).parser();
case DERTags.OCTET_STRING:
return ASN1OctetString.getInstance(this, isExplicit).parser();
}
if (isExplicit) {
return getObject();
}
throw new RuntimeException("implicit tagging not implemented for tag: " + tag);
}
abstract void encode(DEROutputStream out)
throws IOException;
public String toString() {
return "[" + tagNo + "]" + obj;
}
}