Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.adobe.internal.io.ByteWriterFactory
 *  com.adobe.internal.io.ByteWriterFactory$Fixed
 *  com.adobe.internal.io.stream.IO
 *  com.adobe.internal.io.stream.InputByteStream
 *  com.adobe.internal.io.stream.OutputByteStream
 *  com.adobe.internal.io.stream.StreamManager
 *  com.adobe.internal.pdftoolkit.core.cos.CosArray
 *  com.adobe.internal.pdftoolkit.core.cos.CosDocument
 *  com.adobe.internal.pdftoolkit.core.cos.CosObject
 *  com.adobe.internal.pdftoolkit.core.cos.CosStream
 *  com.adobe.internal.pdftoolkit.core.exceptions.PDFCosParseException
 *  com.adobe.internal.pdftoolkit.core.exceptions.PDFException
 *  com.adobe.internal.pdftoolkit.core.exceptions.PDFIOException
 *  com.adobe.internal.pdftoolkit.core.exceptions.PDFInvalidContentException
 *  com.adobe.internal.pdftoolkit.core.exceptions.PDFInvalidDocumentException
 *  com.adobe.internal.pdftoolkit.core.exceptions.PDFSecurityException
 */
package com.adobe.internal.pdftoolkit.pdf.document;

import com.adobe.internal.io.ByteWriterFactory;
import com.adobe.internal.io.stream.IO;
import com.adobe.internal.io.stream.InputByteStream;
import com.adobe.internal.io.stream.OutputByteStream;
import com.adobe.internal.io.stream.StreamManager;
import com.adobe.internal.pdftoolkit.core.cos.CosArray;
import com.adobe.internal.pdftoolkit.core.cos.CosDocument;
import com.adobe.internal.pdftoolkit.core.cos.CosObject;
import com.adobe.internal.pdftoolkit.core.cos.CosStream;
import com.adobe.internal.pdftoolkit.core.exceptions.PDFCosParseException;
import com.adobe.internal.pdftoolkit.core.exceptions.PDFException;
import com.adobe.internal.pdftoolkit.core.exceptions.PDFIOException;
import com.adobe.internal.pdftoolkit.core.exceptions.PDFInvalidContentException;
import com.adobe.internal.pdftoolkit.core.exceptions.PDFInvalidDocumentException;
import com.adobe.internal.pdftoolkit.core.exceptions.PDFSecurityException;
import com.adobe.internal.pdftoolkit.pdf.document.PDFCosObject;
import com.adobe.internal.pdftoolkit.pdf.document.PDFDocument;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;

public class PDFContents
extends PDFCosObject {
    private PDFContents(CosObject cosObject) throws PDFInvalidDocumentException {
        super(cosObject);
    }

    public static PDFContents getInstance(CosObject cosObject) throws PDFInvalidDocumentException {
        if (PDFCosObject.checkNullCosObject(cosObject) == null) {
            return null;
        }
        PDFContents pdfObject = PDFCosObject.getCachedInstance(cosObject, PDFContents.class);
        if (pdfObject == null) {
            pdfObject = new PDFContents(cosObject);
        }
        return pdfObject;
    }

    public static PDFContents newInstance(PDFDocument pdfDocument) throws PDFIOException, PDFSecurityException, PDFInvalidDocumentException {
        CosStream cosObject = PDFCosObject.newCosStream(pdfDocument);
        return new PDFContents((CosObject)cosObject);
    }

    public static PDFContents newInstanceArray(PDFDocument pdfDocument) throws PDFIOException, PDFSecurityException, PDFInvalidDocumentException {
        CosArray cosObject = PDFCosObject.newCosArray(pdfDocument);
        return new PDFContents((CosObject)cosObject);
    }

    public InputByteStream getContents() throws PDFInvalidDocumentException, PDFIOException, PDFSecurityException {
        try {
            if (this.getCosObject() instanceof CosStream) {
                return this.getCosStream().getStreamDecoded();
            }
            if (this.getCosObject() instanceof CosArray) {
                InputByteStream[] ibsArray = this.getStreamsFromCosArray(this.getCosArray());
                return this.getStreamManager().getInputByteStream(ibsArray);
            }
            throw new PDFInvalidContentException("PDFContents should either be a content stream or an array of content streams.");
        }
        catch (IOException e) {
            throw new PDFIOException((Throwable)e);
        }
    }

    public boolean hasContents() {
        if (this.getCosObject() instanceof CosStream || this.getCosObject() instanceof CosArray) {
            return true;
        }
        return false;
    }

    private InputByteStream[] getStreamsFromCosArray(CosArray cosArray) throws PDFIOException {
        try {
            if (cosArray == null) {
                return null;
            }
            ArrayList<InputByteStream> tempByteStreamList = new ArrayList<InputByteStream>();
            for (int i = 0; i < cosArray.size(); ++i) {
                try {
                    if (i > 0) {
                        InputByteStream lastStream = (InputByteStream)tempByteStreamList.get(tempByteStreamList.size() - 1);
                        lastStream.seek(lastStream.length() - 1);
                        int c = lastStream.read();
                        if (c != 48 && c != 10) {
                            byte[] endArr = new byte[]{10};
                            InputByteStream endstream = this.getStreamManager().getInputByteStream(endArr);
                            tempByteStreamList.add(endstream);
                        }
                    }
                    tempByteStreamList.add(cosArray.getStream(i));
                    continue;
                }
                catch (PDFException e) {
                    throw new PDFIOException("Error with Cos Array (" + e.getMessage() + ").", (Throwable)e);
                }
            }
            InputByteStream[] finalByteStreams = new InputByteStream[tempByteStreamList.size()];
            for (int k = 0; k < finalByteStreams.length; ++k) {
                if (tempByteStreamList.get(k) == null) continue;
                finalByteStreams[k] = (InputByteStream)tempByteStreamList.get(k);
            }
            return finalByteStreams;
        }
        catch (IOException e) {
            throw new PDFIOException((Throwable)e);
        }
    }

    private void appendStream(InputByteStream contents, CosStream cosStream) throws PDFInvalidDocumentException, PDFIOException, PDFSecurityException, IOException {
        InputByteStream istream = cosStream.getStreamDecoded();
        if (istream == null || istream.length() == 0) {
            if (istream != null) {
                istream.close();
            }
            cosStream.newDataDecoded(contents);
            return;
        }
        OutputByteStream outputStream = this.getStreamManager().getOutputByteStreamClearDocument(ByteWriterFactory.Fixed.GROWABLE, istream.length());
        IO.copy((InputByteStream)istream, (OutputByteStream)outputStream);
        outputStream.write(13);
        IO.copy((InputByteStream)contents, (OutputByteStream)outputStream);
        InputByteStream newStream = outputStream.closeAndConvert();
        outputStream = null;
        cosStream.newDataDecoded(newStream);
        newStream = null;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private void prependStream(InputByteStream contents, CosStream cosStream) throws PDFCosParseException, PDFInvalidDocumentException, PDFIOException, PDFSecurityException, IOException {
        InputByteStream istream = null;
        try {
            istream = cosStream.getStreamDecoded();
        }
        catch (Exception e) {
            try {
                if (contents != null) {
                    contents.close();
                }
            }
            catch (IOException f) {
                // empty catch block
            }
            throw new PDFIOException((Throwable)e);
        }
        if (istream == null || istream.length() == 0) {
            try {
                if (istream != null) {
                    istream.close();
                }
            }
            catch (IOException e) {
                try {
                    if (contents != null) {
                        contents.close();
                    }
                }
                catch (IOException f) {
                    // empty catch block
                }
                throw e;
            }
            cosStream.newDataDecoded(contents);
            return;
        }
        OutputByteStream outputStream = null;
        try {
            outputStream = this.getStreamManager().getOutputByteStreamClearDocument(ByteWriterFactory.Fixed.GROWABLE, -1);
            IO.copy((InputByteStream)contents, (OutputByteStream)outputStream);
            IO.copy((InputByteStream)istream, (OutputByteStream)outputStream);
        }
        finally {
            try {
                if (contents != null) {
                    contents.close();
                }
            }
            finally {
                if (istream != null) {
                    istream.close();
                }
            }
        }
        istream = null;
        InputByteStream newStream = outputStream.closeAndConvert();
        outputStream = null;
        cosStream.newDataDecoded(newStream);
        newStream = null;
    }

    public void addContents(InputByteStream contents) throws PDFInvalidDocumentException, PDFIOException, PDFSecurityException {
        try {
            if (contents.length() > 0) {
                if (this.getCosObject() instanceof CosStream) {
                    this.appendStream(contents, this.getCosStream());
                } else if (this.getCosObject() instanceof CosArray) {
                    CosArray cosArray = this.getCosArray();
                    CosStream newStream = PDFCosObject.newCosStream(this.getPDFDocument());
                    newStream.newDataDecoded(contents);
                    cosArray.add((CosObject)newStream);
                }
            }
        }
        catch (IOException e) {
            throw new PDFIOException((Throwable)e);
        }
    }

    public void setContents(InputByteStream contents) throws PDFInvalidDocumentException, PDFIOException, PDFSecurityException {
        if (this.getCosObject() instanceof CosStream) {
            this.getCosStream().newDataDecoded(contents);
        } else if (this.getCosObject() instanceof CosArray) {
            CosArray cosArray = this.getCosArray();
            Iterator itr = cosArray.iterator();
            while (itr.hasNext()) {
                itr.next();
                itr.remove();
            }
            CosStream stream = cosArray.getDocument().createCosStream();
            stream.newDataDecoded(contents);
            cosArray.add((CosObject)stream);
        }
    }

    public void prependContents(InputByteStream contents) throws PDFInvalidDocumentException, PDFIOException, PDFSecurityException {
        block18 : {
            try {
                if (this.getCosObject() instanceof CosStream) {
                    this.prependStream(contents, this.getCosStream());
                    break block18;
                }
                if (!(this.getCosObject() instanceof CosArray)) break block18;
                CosStream newStream = null;
                CosArray cosArray = null;
                try {
                    cosArray = this.getCosArray();
                    newStream = PDFCosObject.newCosStream(this.getPDFDocument());
                }
                catch (PDFInvalidDocumentException e) {
                    try {
                        if (contents != null) {
                            contents.close();
                        }
                    }
                    catch (IOException f) {
                        // empty catch block
                    }
                    throw e;
                }
                catch (PDFIOException e) {
                    try {
                        if (contents != null) {
                            contents.close();
                        }
                    }
                    catch (IOException f) {
                        // empty catch block
                    }
                    throw e;
                }
                catch (PDFSecurityException e) {
                    try {
                        if (contents != null) {
                            contents.close();
                        }
                    }
                    catch (IOException f) {
                        // empty catch block
                    }
                    throw e;
                }
                newStream.newDataDecoded(contents);
                int arraySize = cosArray.size();
                if (0 < arraySize) {
                    CosStream lastStream = cosArray.getCosStream(arraySize - 1);
                    cosArray.add(arraySize, (CosObject)lastStream);
                    for (int i = arraySize - 1; 0 < i; --i) {
                        cosArray.set(i, cosArray.get(i - 1));
                    }
                }
                cosArray.set(0, (CosObject)newStream);
            }
            catch (IOException e) {
                throw new PDFIOException((Throwable)e);
            }
        }
    }

    public PDFContentStreamsIterator listIterator() {
        return new PDFContentStreamsIterator();
    }

    public void setOutputFiltersList(CosArray filters) throws PDFCosParseException, PDFIOException, IOException, PDFSecurityException {
        CosObject obj = this.getCosObject();
        if (obj instanceof CosStream) {
            CosStream str = (CosStream)obj;
            str.setOutputFiltersList(filters);
        }
        if (obj instanceof CosArray) {
            CosArray arr = (CosArray)obj;
            for (CosStream str : arr) {
                str.setOutputFiltersList(filters);
            }
        }
    }

    /*
     * This class specifies class file version 49.0 but uses Java 6 signatures.  Assumed Java 6.
     */
    public class PDFContentStreamsIterator
    implements ListIterator<InputByteStream> {
        private boolean isArray;
        private int arraySize;
        private int nextIndex;
        public ListIterator arrayIter;

        PDFContentStreamsIterator() {
            if (PDFContents.this.getCosObject() instanceof CosArray) {
                this.isArray = true;
                this.arraySize = PDFContents.this.getCosArray().size();
                this.arrayIter = PDFContents.this.getCosArray().listIterator();
            } else if (PDFContents.this.getCosObject() instanceof CosStream) {
                this.isArray = false;
                this.arraySize = 1;
                this.arrayIter = null;
            } else {
                this.isArray = false;
                this.arraySize = 0;
                this.arrayIter = null;
            }
            this.nextIndex = 0;
        }

        @Override
        public int previousIndex() {
            if (this.isArray) {
                return this.arrayIter.previousIndex();
            }
            return this.nextIndex > 0 ? 0 : -1;
        }

        @Override
        public int nextIndex() {
            if (this.isArray) {
                return this.arrayIter.nextIndex();
            }
            return this.nextIndex < this.arraySize ? this.nextIndex : this.arraySize;
        }

        @Override
        public boolean hasNext() {
            if (this.isArray) {
                return this.arrayIter.hasNext();
            }
            return this.nextIndex < this.arraySize;
        }

        @Override
        public InputByteStream next() {
            try {
                if (this.isArray) {
                    return ((CosStream)this.arrayIter.next()).getStreamDecoded();
                }
                if (this.hasNext()) {
                    ++this.nextIndex;
                    return PDFContents.this.getCosStream().getStreamDecoded();
                }
                throw new NoSuchElementException();
            }
            catch (PDFException e) {
                NoSuchElementException newException = new NoSuchElementException("Error occured while getting next element.");
                newException.initCause((Throwable)e);
                throw newException;
            }
        }

        @Override
        public boolean hasPrevious() {
            if (this.isArray) {
                return this.arrayIter.hasPrevious();
            }
            return this.nextIndex > 0;
        }

        @Override
        public InputByteStream previous() {
            try {
                if (this.isArray) {
                    return ((CosStream)this.arrayIter.previous()).getStreamDecoded();
                }
                if (this.hasPrevious()) {
                    --this.nextIndex;
                    return PDFContents.this.getCosStream().getStreamDecoded();
                }
                throw new NoSuchElementException();
            }
            catch (PDFException e) {
                NoSuchElementException newException = new NoSuchElementException("Error occured while getting next element.");
                newException.initCause((Throwable)e);
                throw newException;
            }
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

        @Override
        public void set(InputByteStream o) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void add(InputByteStream o) {
            throw new UnsupportedOperationException();
        }
    }

}