gt:                 if (cachedContent == null) {
context: package play.data.parsing;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.ByteArrayInputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.OutputStream;
  
  import org.apache.commons.fileupload.*;
  import org.apache.commons.fileupload.util.Closeable;
  import org.apache.commons.fileupload.util.LimitedInputStream;
  import org.apache.commons.fileupload.util.Streams;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.UnsupportedEncodingException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.NoSuchElementException;
  
  import org.apache.commons.fileupload.disk.DiskFileItem;
  import org.apache.commons.io.FileCleaningTracker;
  import org.apache.commons.io.output.DeferredFileOutputStream;
  
  import play.Logger;
  import play.Play;
  import play.data.FileUpload;
  import play.data.MemoryUpload;
  import play.data.Upload;
  import play.exceptions.UnexpectedException;
  import play.mvc.Http.Request;
  import play.utils.HTTP;
  
  /**
   * From Apache commons fileupload.
   * http://commons.apache.org/fileupload/
   */
  public class ApacheMultipartParser extends DataParser {
  
      /*
       * Copyright 2001-2004 The Apache Software Foundation
       *
       * Licensed 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.
       *
       * <p> The default implementation of the
       * {@link org.apache.commons.fileupload.FileItem FileItem} interface.
       *
       * <p> After retrieving an instance of this class from a {@link
       * org.apache.commons.fileupload.DiskFileUpload DiskFileUpload} instance (see
       * {@link org.apache.commons.fileupload.DiskFileUpload
       * #parseRequest(javax.servlet.http.HttpServletRequest)}), you may
       * either request all contents of file at once using {@link #get()} or
       * request an {@link java.io.InputStream InputStream} with
       * {@link #getInputStream()} and process the file without attempting to load
       * it into memory, which may come handy with large files.
       *
       * @author <a href="mailto:Rafal.Krzewski@e-point.pl">Rafal Krzewski</a>
       * @author <a href="mailto:sean@informage.net">Sean Legassick</a>
       * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
       * @author <a href="mailto:jmcnally@apache.org">John McNally</a>
       * @author <a href="mailto:martinc@apache.org">Martin Cooper</a>
       * @author Sean C. Sullivan
       *
       * @since FileUpload 1.1
       *
       * @version $Id: DiskFileItem.java,v 1.3 2005/07/26 03:05:02 rafaelsteil Exp $
       */
      public static class AutoFileItem implements FileItem {
  
          private static FileCleaningTracker fileTracker;
  
          static {
              fileTracker = new FileCleaningTracker();
          }
  
          // ----------------------------------------------------- Manifest constants
          /**
           * Default content charset to be used when no explicit charset
           * parameter is provided by the sender. Media subtypes of the
           * "text" type are defined to have a default charset value of
           * "ISO-8859-1" when received via HTTP.
           */
          public static final String DEFAULT_CHARSET = "ISO-8859-1";
          /**
           * Size of buffer to use when writing an item to disk.
           */
          private static final int WRITE_BUFFER_SIZE = 2048;
  
          // ----------------------------------------------------------- Data members
          /**
           * Counter used in unique identifier generation.
           */
          private static int counter = 0;
          /**
           * The name of the form field as provided by the browser.
           */
          private String fieldName;
          /**
           * The content type passed by the browser, or <code>null</code> if
           * not defined.
           */
          private String contentType;
          /**
           * Whether or not this item is a simple form field.
           */
          private boolean isFormField;
          /**
           * The original filename in the user's filesystem.
           */
          private String fileName;
          /**
           * The threshold above which uploads will be stored on disk.
           */
          private int sizeThreshold;
          /**
           * The directory in which uploaded files will be stored, if stored on disk.
           */
          private File repository;
          /**
           * Cached contents of the file.
           */
          private byte[] cachedContent;
          /**
           * Output stream for this item.
           */
          private DeferredFileOutputStream dfos;
          
          /**
           * The file items headers. 
           */
          private FileItemHeaders headers;
  
          public AutoFileItem(FileItemStream stream) {
              this.fieldName = stream.getFieldName();
              this.contentType = stream.getContentType();
              this.isFormField = stream.isFormField();
              this.fileName = stream.getName();
              this.sizeThreshold = Integer.parseInt(Play.configuration.getProperty("upload.threshold", "10240"));
              this.repository = null;
          }
          // ------------------------------- Methods from javax.activation.DataSource
  
          /**
           * Returns an {@link java.io.InputStream InputStream} that can be
           * used to retrieve the contents of the file.
           *
           * @return An {@link java.io.InputStream InputStream} that can be
           *         used to retrieve the contents of the file.
           * @throws IOException if an error occurs.
           */
          public InputStream getInputStream()
                  throws IOException {
              if (!dfos.isInMemory()) {
                  return new FileInputStream(dfos.getFile());
              }
  
              if (cachedContent == null) {
                  cachedContent = dfos.getData();
              }
              return new ByteArrayInputStream(cachedContent);
          }
  
          /**
           * Returns the content type passed by the agent or <code>null</code> if
           * not defined.
           *
           * @return The content type passed by the agent or <code>null</code> if
           *         not defined.
           */
          public String getContentType() {
              return contentType;
          }
  
          /**
           * Returns the content charset passed by the agent or <code>null</code> if
           * not defined.
           *
           * @return The content charset passed by the agent or <code>null</code> if
           *         not defined.
           */
          public String getCharSet() {
              ParameterParser parser = new ParameterParser();
              parser.setLowerCaseNames(true);
              // Parameter parser can handle null input
              Map params = parser.parse(getContentType(), ';');
              return (String) params.get("charset");
          }
  
          /**
           * Returns the original filename in the client's filesystem.
           *
           * @return The original filename in the client's filesystem.
           */
          public String getName() {
              return fileName;
          }
          // ------------------------------------------------------- FileItem methods
  
          /**
           * Provides a hint as to whether or not the file contents will be read
           * from memory.
           *
           * @return <code>true</code> if the file contents will be read
           *         from memory; <code>false</code> otherwise.
           */
          public boolean isInMemory() {
              return (dfos.isInMemory());
          }
  
          /**
           * Returns the size of the file.
           *
           * @return The size of the file, in bytes.
           */
          public long getSize() {
              if (cachedContent != null) {
                  return cachedContent.length;
              } else if (dfos.isInMemory()) {
                  return dfos.getData().length;
              } else {
                  return dfos.getFile().length();
              }
          }
  
          /**
           * Returns the contents of the file as an array of bytes.  If the
           * contents of the file were not yet cached in memory, they will be
           * loaded from the disk storage and cached.
           *
           * @return The contents of the file as an array of bytes.
           */
          public byte[] get() {
              if (dfos.isInMemory()) {
  