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

package org.bouncycastle.asn1;

import java.util.Iterator;
import java.util.Enumeration;
import java.io.IOException;

class LazyEncodedSequence extends ASN1Sequence
{
    private byte[] encoded;
    
    LazyEncodedSequence(final byte[] encoded) throws IOException {
        if (null == encoded) {
            throw new NullPointerException("'encoded' cannot be null");
        }
        this.encoded = encoded;
    }
    
    @Override
    public ASN1Encodable getObjectAt(final int n) {
        this.force();
        return super.getObjectAt(n);
    }
    
    @Override
    public Enumeration getObjects() {
        final byte[] contents = this.getContents();
        if (null != contents) {
            return new LazyConstructionEnumeration(contents);
        }
        return super.getObjects();
    }
    
    @Override
    public int hashCode() {
        this.force();
        return super.hashCode();
    }
    
    @Override
    public Iterator<ASN1Encodable> iterator() {
        this.force();
        return super.iterator();
    }
    
    @Override
    public int size() {
        this.force();
        return super.size();
    }
    
    @Override
    public ASN1Encodable[] toArray() {
        this.force();
        return super.toArray();
    }
    
    @Override
    ASN1Encodable[] toArrayInternal() {
        this.force();
        return super.toArrayInternal();
    }
    
    @Override
    int encodedLength(final boolean b) throws IOException {
        final byte[] contents = this.getContents();
        if (null != contents) {
            return ASN1OutputStream.getLengthOfEncodingDL(b, contents.length);
        }
        return super.toDLObject().encodedLength(b);
    }
    
    @Override
    void encode(final ASN1OutputStream asn1OutputStream, final boolean b) throws IOException {
        final byte[] contents = this.getContents();
        if (null != contents) {
            asn1OutputStream.writeEncodingDL(b, 48, contents);
            return;
        }
        super.toDLObject().encode(asn1OutputStream, b);
    }
    
    @Override
    ASN1BitString toASN1BitString() {
        return ((ASN1Sequence)this.toDLObject()).toASN1BitString();
    }
    
    @Override
    ASN1External toASN1External() {
        return ((ASN1Sequence)this.toDLObject()).toASN1External();
    }
    
    @Override
    ASN1OctetString toASN1OctetString() {
        return ((ASN1Sequence)this.toDLObject()).toASN1OctetString();
    }
    
    @Override
    ASN1Set toASN1Set() {
        return ((ASN1Sequence)this.toDLObject()).toASN1Set();
    }
    
    @Override
    ASN1Primitive toDERObject() {
        this.force();
        return super.toDERObject();
    }
    
    @Override
    ASN1Primitive toDLObject() {
        this.force();
        return super.toDLObject();
    }
    
    private synchronized void force() {
        if (null != this.encoded) {
            final ASN1InputStream asn1InputStream = new ASN1InputStream(this.encoded, true);
            try {
                final ASN1EncodableVector vector = asn1InputStream.readVector();
                asn1InputStream.close();
                this.elements = vector.takeElements();
                this.encoded = null;
            }
            catch (final IOException obj) {
                throw new ASN1ParsingException("malformed ASN.1: " + obj, obj);
            }
        }
    }
    
    private synchronized byte[] getContents() {
        return this.encoded;
    }
}