/** * Return an ASN1 set 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 * set - 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 sets 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. * @exception IllegalArgumentException if the tagged object cannot * be converted. */ public static ASN1Set getInstance( ASN1TaggedObject obj, bool explicitly) { if (explicitly) { if (!obj.isExplicit()) { throw new ArgumentException("object implicit - explicit expected."); } return((ASN1Set)obj.getObject()); } else { // // constructed object which appears to be explicitly tagged // and it's really implicit means we have to add the // surrounding sequence. // if (obj.isExplicit()) { ASN1Set set = new DERSet(obj.getObject()); return(set); } else { if (obj.getObject() is ASN1Set) { return((ASN1Set)obj.getObject()); } // // in this case the parser returns a sequence, convert it // into a set. // ASN1EncodableVector v = new ASN1EncodableVector(); if (obj.getObject() is ASN1Sequence) { ASN1Sequence s = (ASN1Sequence)obj.getObject(); IEnumerator e = s.getObjects(); while (e.MoveNext()) { v.add((ASN1Encodable)e.Current); } return(new DERSet(v)); } } } throw new ArgumentException( "unknown object in getInstanceFromTagged"); }
/** * 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. * @exception IllegalArgumentException if the tagged object cannot * be converted. */ public static ASN1Sequence getInstance( ASN1TaggedObject obj, bool explicitly) { if (explicitly) { if (!obj.isExplicit()) { throw new ArgumentException("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 is BERTaggedObject) { return(new BERSequence(obj.getObject())); } else { return(new DERSequence(obj.getObject())); } } else { if (obj.getObject() is ASN1Sequence) { return((ASN1Sequence)obj.getObject()); } } } throw new ArgumentException( "unknown object in getInstanceFromTagged"); }