// 
// Decompiled by Procyon v0.6.0
// 

package org.bouncycastle.asn1;

import java.io.IOException;

public abstract class ASN1Util
{
    static ASN1TaggedObject checkContextTag(final ASN1TaggedObject asn1TaggedObject, final int n) {
        return checkTag(asn1TaggedObject, 128, n);
    }
    
    static ASN1TaggedObjectParser checkContextTag(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n) {
        return checkTag(asn1TaggedObjectParser, 128, n);
    }
    
    static ASN1TaggedObject checkContextTagClass(final ASN1TaggedObject asn1TaggedObject) {
        return checkTagClass(asn1TaggedObject, 128);
    }
    
    static ASN1TaggedObjectParser checkContextTagClass(final ASN1TaggedObjectParser asn1TaggedObjectParser) {
        return checkTagClass(asn1TaggedObjectParser, 128);
    }
    
    static ASN1TaggedObject checkTag(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2) {
        if (!asn1TaggedObject.hasTag(n, n2)) {
            throw new IllegalStateException("Expected " + getTagText(n, n2) + " tag but found " + getTagText(asn1TaggedObject));
        }
        return asn1TaggedObject;
    }
    
    static ASN1TaggedObjectParser checkTag(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2) {
        if (!asn1TaggedObjectParser.hasTag(n, n2)) {
            throw new IllegalStateException("Expected " + getTagText(n, n2) + " tag but found " + getTagText(asn1TaggedObjectParser));
        }
        return asn1TaggedObjectParser;
    }
    
    static ASN1TaggedObject checkTagClass(final ASN1TaggedObject asn1TaggedObject, final int n) {
        if (!asn1TaggedObject.hasTagClass(n)) {
            throw new IllegalStateException("Expected " + getTagClassText(n) + " tag but found " + getTagClassText(asn1TaggedObject));
        }
        return asn1TaggedObject;
    }
    
    static ASN1TaggedObjectParser checkTagClass(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n) {
        if (!asn1TaggedObjectParser.hasTagClass(n)) {
            throw new IllegalStateException("Expected " + getTagClassText(n) + " tag but found " + getTagClassText(asn1TaggedObjectParser));
        }
        return asn1TaggedObjectParser;
    }
    
    public static Object getInstanceChoiceBaseObject(final ASN1TaggedObject asn1TaggedObject, final boolean b, final String str) {
        if (!b) {
            throw new IllegalArgumentException("Implicit tagging cannot be used with untagged choice type " + str + " (X.680 30.6, 30.8).");
        }
        if (asn1TaggedObject == null) {
            throw new NullPointerException("'taggedObject' cannot be null");
        }
        return getExplicitContextBaseObject(asn1TaggedObject);
    }
    
    public static Object getTaggedChoiceBaseObject(final ASN1TaggedObject asn1TaggedObject, final boolean b, final String str) {
        if (!b) {
            throw new IllegalArgumentException("Implicit tagging cannot be used with untagged choice type " + str + " (X.680 30.6, 30.8).");
        }
        if (asn1TaggedObject == null) {
            throw new NullPointerException("'taggedObject' cannot be null");
        }
        return asn1TaggedObject.getExplicitBaseObject();
    }
    
    static String getTagClassText(final ASN1Tag asn1Tag) {
        return getTagClassText(asn1Tag.getTagClass());
    }
    
    public static String getTagClassText(final ASN1TaggedObject asn1TaggedObject) {
        return getTagClassText(asn1TaggedObject.getTagClass());
    }
    
    public static String getTagClassText(final ASN1TaggedObjectParser asn1TaggedObjectParser) {
        return getTagClassText(asn1TaggedObjectParser.getTagClass());
    }
    
    public static String getTagClassText(final int n) {
        switch (n) {
            case 64: {
                return "APPLICATION";
            }
            case 128: {
                return "CONTEXT";
            }
            case 192: {
                return "PRIVATE";
            }
            default: {
                return "UNIVERSAL";
            }
        }
    }
    
    static String getTagText(final ASN1Tag asn1Tag) {
        return getTagText(asn1Tag.getTagClass(), asn1Tag.getTagNumber());
    }
    
    public static String getTagText(final ASN1TaggedObject asn1TaggedObject) {
        return getTagText(asn1TaggedObject.getTagClass(), asn1TaggedObject.getTagNo());
    }
    
    public static String getTagText(final ASN1TaggedObjectParser asn1TaggedObjectParser) {
        return getTagText(asn1TaggedObjectParser.getTagClass(), asn1TaggedObjectParser.getTagNo());
    }
    
    public static String getTagText(final int n, final int n2) {
        switch (n) {
            case 64: {
                return "[APPLICATION " + n2 + "]";
            }
            case 128: {
                return "[CONTEXT " + n2 + "]";
            }
            case 192: {
                return "[PRIVATE " + n2 + "]";
            }
            default: {
                return "[UNIVERSAL " + n2 + "]";
            }
        }
    }
    
    public static ASN1Object getExplicitBaseObject(final ASN1TaggedObject asn1TaggedObject, final int n) {
        return checkTagClass(asn1TaggedObject, n).getExplicitBaseObject();
    }
    
    public static ASN1Object getExplicitBaseObject(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2) {
        return checkTag(asn1TaggedObject, n, n2).getExplicitBaseObject();
    }
    
    public static ASN1Object getExplicitContextBaseObject(final ASN1TaggedObject asn1TaggedObject) {
        return getExplicitBaseObject(asn1TaggedObject, 128);
    }
    
    public static ASN1Object getExplicitContextBaseObject(final ASN1TaggedObject asn1TaggedObject, final int n) {
        return getExplicitBaseObject(asn1TaggedObject, 128, n);
    }
    
    public static ASN1Object tryGetExplicitBaseObject(final ASN1TaggedObject asn1TaggedObject, final int n) {
        if (!asn1TaggedObject.hasTagClass(n)) {
            return null;
        }
        return asn1TaggedObject.getExplicitBaseObject();
    }
    
    public static ASN1Object tryGetExplicitBaseObject(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2) {
        if (!asn1TaggedObject.hasTag(n, n2)) {
            return null;
        }
        return asn1TaggedObject.getExplicitBaseObject();
    }
    
    public static ASN1Object tryGetExplicitContextBaseObject(final ASN1TaggedObject asn1TaggedObject) {
        return tryGetExplicitBaseObject(asn1TaggedObject, 128);
    }
    
    public static ASN1Object tryGetExplicitContextBaseObject(final ASN1TaggedObject asn1TaggedObject, final int n) {
        return tryGetExplicitBaseObject(asn1TaggedObject, 128, n);
    }
    
    public static ASN1TaggedObject getExplicitBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n) {
        return checkTagClass(asn1TaggedObject, n).getExplicitBaseTagged();
    }
    
    public static ASN1TaggedObject getExplicitBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2) {
        return checkTag(asn1TaggedObject, n, n2).getExplicitBaseTagged();
    }
    
    public static ASN1TaggedObject getExplicitContextBaseTagged(final ASN1TaggedObject asn1TaggedObject) {
        return getExplicitBaseTagged(asn1TaggedObject, 128);
    }
    
    public static ASN1TaggedObject getExplicitContextBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n) {
        return getExplicitBaseTagged(asn1TaggedObject, 128, n);
    }
    
    public static ASN1TaggedObject tryGetExplicitBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n) {
        if (!asn1TaggedObject.hasTagClass(n)) {
            return null;
        }
        return asn1TaggedObject.getExplicitBaseTagged();
    }
    
    public static ASN1TaggedObject tryGetExplicitBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2) {
        if (!asn1TaggedObject.hasTag(n, n2)) {
            return null;
        }
        return asn1TaggedObject.getExplicitBaseTagged();
    }
    
    public static ASN1TaggedObject tryGetExplicitContextBaseTagged(final ASN1TaggedObject asn1TaggedObject) {
        return tryGetExplicitBaseTagged(asn1TaggedObject, 128);
    }
    
    public static ASN1TaggedObject tryGetExplicitContextBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n) {
        return tryGetExplicitBaseTagged(asn1TaggedObject, 128, n);
    }
    
    public static ASN1TaggedObject getImplicitBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2, final int n3, final int n4) {
        return checkTag(asn1TaggedObject, n, n2).getImplicitBaseTagged(n3, n4);
    }
    
    public static ASN1TaggedObject getImplicitContextBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2, final int n3) {
        return getImplicitBaseTagged(asn1TaggedObject, 128, n, n2, n3);
    }
    
    public static ASN1TaggedObject tryGetImplicitBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2, final int n3, final int n4) {
        if (!asn1TaggedObject.hasTag(n, n2)) {
            return null;
        }
        return asn1TaggedObject.getImplicitBaseTagged(n3, n4);
    }
    
    public static ASN1TaggedObject tryGetImplicitContextBaseTagged(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2, final int n3) {
        return tryGetImplicitBaseTagged(asn1TaggedObject, 128, n, n2, n3);
    }
    
    public static ASN1Primitive getBaseUniversal(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2, final boolean b, final int n3) {
        return checkTag(asn1TaggedObject, n, n2).getBaseUniversal(b, n3);
    }
    
    public static ASN1Primitive getContextBaseUniversal(final ASN1TaggedObject asn1TaggedObject, final int n, final boolean b, final int n2) {
        return getBaseUniversal(asn1TaggedObject, 128, n, b, n2);
    }
    
    public static ASN1Primitive tryGetBaseUniversal(final ASN1TaggedObject asn1TaggedObject, final int n, final int n2, final boolean b, final int n3) {
        if (!asn1TaggedObject.hasTag(n, n2)) {
            return null;
        }
        return asn1TaggedObject.getBaseUniversal(b, n3);
    }
    
    public static ASN1Primitive tryGetContextBaseUniversal(final ASN1TaggedObject asn1TaggedObject, final int n, final boolean b, final int n2) {
        return tryGetBaseUniversal(asn1TaggedObject, 128, n, b, n2);
    }
    
    public static ASN1TaggedObjectParser parseExplicitBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n) throws IOException {
        return checkTagClass(asn1TaggedObjectParser, n).parseExplicitBaseTagged();
    }
    
    public static ASN1TaggedObjectParser parseExplicitBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2) throws IOException {
        return checkTag(asn1TaggedObjectParser, n, n2).parseExplicitBaseTagged();
    }
    
    public static ASN1TaggedObjectParser parseExplicitContextBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser) throws IOException {
        return parseExplicitBaseTagged(asn1TaggedObjectParser, 128);
    }
    
    public static ASN1TaggedObjectParser parseExplicitContextBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n) throws IOException {
        return parseExplicitBaseTagged(asn1TaggedObjectParser, 128, n);
    }
    
    public static ASN1TaggedObjectParser tryParseExplicitBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n) throws IOException {
        if (!asn1TaggedObjectParser.hasTagClass(n)) {
            return null;
        }
        return asn1TaggedObjectParser.parseExplicitBaseTagged();
    }
    
    public static ASN1TaggedObjectParser tryParseExplicitBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2) throws IOException {
        if (!asn1TaggedObjectParser.hasTag(n, n2)) {
            return null;
        }
        return asn1TaggedObjectParser.parseExplicitBaseTagged();
    }
    
    public static ASN1TaggedObjectParser tryParseExplicitContextBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser) throws IOException {
        return tryParseExplicitBaseTagged(asn1TaggedObjectParser, 128);
    }
    
    public static ASN1TaggedObjectParser tryParseExplicitContextBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n) throws IOException {
        return tryParseExplicitBaseTagged(asn1TaggedObjectParser, 128, n);
    }
    
    public static ASN1TaggedObjectParser parseImplicitBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2, final int n3, final int n4) throws IOException {
        return checkTag(asn1TaggedObjectParser, n, n2).parseImplicitBaseTagged(n3, n4);
    }
    
    public static ASN1TaggedObjectParser parseImplicitContextBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2, final int n3) throws IOException {
        return parseImplicitBaseTagged(asn1TaggedObjectParser, 128, n, n2, n3);
    }
    
    public static ASN1TaggedObjectParser tryParseImplicitBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2, final int n3, final int n4) throws IOException {
        if (!asn1TaggedObjectParser.hasTag(n, n2)) {
            return null;
        }
        return asn1TaggedObjectParser.parseImplicitBaseTagged(n3, n4);
    }
    
    public static ASN1TaggedObjectParser tryParseImplicitContextBaseTagged(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2, final int n3) throws IOException {
        return tryParseImplicitBaseTagged(asn1TaggedObjectParser, 128, n, n2, n3);
    }
    
    public static ASN1Encodable parseBaseUniversal(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2, final boolean b, final int n3) throws IOException {
        return checkTag(asn1TaggedObjectParser, n, n2).parseBaseUniversal(b, n3);
    }
    
    public static ASN1Encodable parseContextBaseUniversal(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final boolean b, final int n2) throws IOException {
        return parseBaseUniversal(asn1TaggedObjectParser, 128, n, b, n2);
    }
    
    public static ASN1Encodable tryParseBaseUniversal(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2, final boolean b, final int n3) throws IOException {
        if (!asn1TaggedObjectParser.hasTag(n, n2)) {
            return null;
        }
        return asn1TaggedObjectParser.parseBaseUniversal(b, n3);
    }
    
    public static ASN1Encodable tryParseContextBaseUniversal(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final boolean b, final int n2) throws IOException {
        return tryParseBaseUniversal(asn1TaggedObjectParser, 128, n, b, n2);
    }
    
    public static ASN1Encodable parseExplicitBaseObject(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2) throws IOException {
        return checkTag(asn1TaggedObjectParser, n, n2).parseExplicitBaseObject();
    }
    
    public static ASN1Encodable parseExplicitContextBaseObject(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n) throws IOException {
        return parseExplicitBaseObject(asn1TaggedObjectParser, 128, n);
    }
    
    public static ASN1Encodable tryParseExplicitBaseObject(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n, final int n2) throws IOException {
        if (!asn1TaggedObjectParser.hasTag(n, n2)) {
            return null;
        }
        return asn1TaggedObjectParser.parseExplicitBaseObject();
    }
    
    public static ASN1Encodable tryParseExplicitContextBaseObject(final ASN1TaggedObjectParser asn1TaggedObjectParser, final int n) throws IOException {
        return tryParseExplicitBaseObject(asn1TaggedObjectParser, 128, n);
    }
}