modules/axiom-api/src/main/java/org/apache/axiom/attachments/PartContentFactory.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.axiom.attachments;

import org.apache.axiom.attachments.impl.BufferUtils;
import org.apache.axiom.attachments.lifecycle.LifecycleManager;
import org.apache.axiom.attachments.utils.BAAInputStream;
import org.apache.axiom.attachments.utils.BAAOutputStream;
import org.apache.axiom.om.OMException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.InputStream;

/**
 * Factory for {@link PartContent} objects. There are different ways to store the content of a part
 * (backing file or backing array etc.). These different implementations should not be exposed to
 * the other layers of the code. The {@link PartContentFactory} helps maintain this abstraction, and
 * makes it easier to add new implementations.
 */
class PartContentFactory {
    private static final Log log = LogFactory.getLog(PartContentFactory.class);
    
    /**
     * Creates a {@link PartContent} object from a given input stream. The remaining parameters are
     * used to determine if the content should be stored in memory (byte buffers) or backed by a
     * file.
     * 
     * @param manager
     * @param in
     * @param isRootPart
     * @param thresholdSize
     * @param attachmentDir
     * @param messageContentLength
     * @return Part
     * @throws OMException
     *             if any exception is encountered while processing.
     */
    static PartContent createPartContent(LifecycleManager manager, InputStream in,
                    boolean isRootPart,
                    int thresholdSize,
                    String attachmentDir,
                    int messageContentLength
                    ) throws OMException {
        if(log.isDebugEnabled()){
            log.debug("Start createPart()");
            log.debug("  isRootPart=" + isRootPart);
            log.debug("  thresholdSize= " + thresholdSize);
            log.debug("  attachmentDir=" + attachmentDir);
            log.debug("  messageContentLength " + messageContentLength);
        }
        
        try {
            if (isRootPart ||
                    thresholdSize <= 0 ||  
                    (messageContentLength > 0 && 
                            messageContentLength < thresholdSize)) {
                // If the entire message is less than the threshold size, 
                // keep it in memory.
                // If this is the root part, keep it in memory.

                // Get the bytes of the data without a lot 
                // of resizing and GC.  The BAAOutputStream 
                // keeps the data in non-contiguous byte buffers.
                BAAOutputStream baaos = new BAAOutputStream();
                BufferUtils.inputStream2OutputStream(in, baaos);
                return new PartContentOnMemory(baaos.buffers(), baaos.length());
            } else {
                // We need to read the input stream to determine whether
                // the size is bigger or smaller than the threshold.
                BAAOutputStream baaos = new BAAOutputStream();
                int count = BufferUtils.inputStream2OutputStream(in, baaos, thresholdSize);

                if (count < thresholdSize) {
                    return new PartContentOnMemory(baaos.buffers(), baaos.length());
                } else {
                    // A BAAInputStream is an input stream over a list of non-contiguous 4K buffers.
                    BAAInputStream baais = 
                        new BAAInputStream(baaos.buffers(), baaos.length());

                    return new PartContentOnFile(manager, 
                                          baais,
                                          in, 
                                          attachmentDir);
                }
            } 
        } catch (Exception e) {
            throw new OMException(e);
        } 
    }
}