axis-rt-core/src/main/java/org/apache/axis/utils/ByteArray.java - axis-axis1-java - Git at Google

 /*
  * 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.
  */
 package org.apache.axis.utils;

 import org.apache.axis.AxisEngine;
 import org.apache.axis.AxisProperties;

 import java.io.BufferedInputStream;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;

 /**
  * Class ByteArray
  */
 public class ByteArray extends OutputStream {

     protected static double DEFAULT_CACHE_INCREMENT = 2.5;
     protected static int DEFAULT_RESIDENT_SIZE = 512 * 1024 * 1024; // 512 MB
     protected static boolean DEFAULT_ENABLE_BACKING_STORE = true;
     protected static int WORKING_BUFFER_SIZE = 8192;

     protected org.apache.axis.utils.ByteArrayOutputStream cache = null;

     protected int max_size = 0;
     protected File bs_handle = null;
     protected OutputStream bs_stream = null;
     protected long count = 0;
     protected boolean enableBackingStore = DEFAULT_ENABLE_BACKING_STORE;

     public boolean isEnableBackingStore() {
         return enableBackingStore;
     }

     public void setEnableBackingStore(boolean enableBackingStore) {
         this.enableBackingStore = enableBackingStore;
     }

     public static boolean isDEFAULT_ENABLE_BACKING_STORE() {
         return DEFAULT_ENABLE_BACKING_STORE;
     }

     public static void setDEFAULT_ENABLE_BACKING_STORE(
             boolean DEFAULT_ENABLE_BACKING_STORE) {
         ByteArray.DEFAULT_ENABLE_BACKING_STORE = DEFAULT_ENABLE_BACKING_STORE;
     }

     public static int getDEFAULT_RESIDENT_SIZE() {
         return DEFAULT_RESIDENT_SIZE;
     }

     public static void setDEFAULT_RESIDENT_SIZE(int DEFAULT_RESIDENT_SIZE) {
         ByteArray.DEFAULT_RESIDENT_SIZE = DEFAULT_RESIDENT_SIZE;
     }

     public static double getDEFAULT_CACHE_INCREMENT() {
         return DEFAULT_CACHE_INCREMENT;
     }

     public static void setDEFAULT_CACHE_INCREMENT(
             double DEFAULT_CACHE_INCREMENT) {
         ByteArray.DEFAULT_CACHE_INCREMENT = DEFAULT_CACHE_INCREMENT;
     }

     static {
         String value;
         value = AxisProperties.getProperty(
                 AxisEngine.PROP_BYTE_BUFFER_CACHE_INCREMENT,
                 "" + DEFAULT_CACHE_INCREMENT);
         DEFAULT_CACHE_INCREMENT = Double.parseDouble(value);
         value = AxisProperties.getProperty(
                 AxisEngine.PROP_BYTE_BUFFER_RESIDENT_MAX_SIZE,
                 "" + DEFAULT_RESIDENT_SIZE);
         DEFAULT_RESIDENT_SIZE = Integer.parseInt(value);
         value = AxisProperties.getProperty(
                 AxisEngine.PROP_BYTE_BUFFER_WORK_BUFFER_SIZE,
                 "" + WORKING_BUFFER_SIZE);
         WORKING_BUFFER_SIZE = Integer.parseInt(value);
         value =
                 AxisProperties.getProperty(AxisEngine.PROP_BYTE_BUFFER_BACKING,
                         "" + DEFAULT_ENABLE_BACKING_STORE);
         if (value.equalsIgnoreCase("true") ||
                 value.equals("1") ||
                 value.equalsIgnoreCase("yes")) {
             DEFAULT_ENABLE_BACKING_STORE = true;
         } else {
             DEFAULT_ENABLE_BACKING_STORE = false;
         }
     }

     /**
      * Constructor ByteArray
      */
     public ByteArray() {
         this(DEFAULT_RESIDENT_SIZE);
     }

     /**
      * Constructor ByteArray
      *
      * @param max_resident_size
      */
     public ByteArray(int max_resident_size) {
         this(0, max_resident_size);
     }

     /**
      * Constructor ByteArray
      *
      * @param probable_size
      * @param max_resident_size
      */
     public ByteArray(int probable_size, int max_resident_size) {
         if (probable_size > max_resident_size) {
             probable_size = 0;
         }
         if (probable_size < WORKING_BUFFER_SIZE) {
             probable_size = WORKING_BUFFER_SIZE;
         }
         cache = new org.apache.axis.utils.ByteArrayOutputStream(probable_size);
         max_size = max_resident_size;
     }

     /**
      * Method write
      *
      * @param bytes
      * @throws IOException
      */
     public void write(byte bytes[]) throws IOException {
         write(bytes, 0, bytes.length);
     }

     /**
      * Method write
      *
      * @param bytes
      * @param start
      * @param length
      * @throws IOException
      */
     public void write(byte bytes[], int start, int length) throws IOException {
         count += length;
         if (cache != null) {
             increaseCapacity(length);
         }
         if (cache != null) {
             cache.write(bytes, start, length);
         } else if (bs_stream != null) {
             bs_stream.write(bytes, start, length);
         } else {
             throw new IOException("ByteArray does not have a backing store!");
         }
     }

     /**
      * Method write
      *
      * @param b
      * @throws IOException
      */
     public void write(int b) throws IOException {
         count += 1;
         if (cache != null) {
             increaseCapacity(1);
         }
         if (cache != null) {
             cache.write(b);
         } else if (bs_stream != null) {
             bs_stream.write(b);
         } else {
             throw new IOException("ByteArray does not have a backing store!");
         }
     }

     /**
      * Method close
      *
      * @throws IOException
      */
     public void close() throws IOException {
         if (bs_stream != null) {
             bs_stream.close();
             bs_stream = null;
         }
     }

     /**
      * Method size
      *
      * @return
      */
     public long size() {
         return count;
     }

     /**
      * Method flush
      *
      * @throws IOException
      */
     public void flush() throws IOException {
         if (bs_stream != null) {
             bs_stream.flush();
         }
     }

     /**
      * Method increaseCapacity
      *
      * @param count
      * @throws IOException
      */
     protected void increaseCapacity(int count) throws IOException {
         if (cache == null) {
             return;
         }
         if (count + cache.size() <= max_size) {
             return;
         } else if (enableBackingStore) {
             switchToBackingStore();
         } else {
             throw new IOException("ByteArray can not increase capacity by " +
                     count +
                     " due to max size limit of " + max_size);
         }
     }

     /**
      * Method discardBuffer
      */
     public synchronized void discardBuffer() {
         cache = null;
         if (bs_stream != null) {
             try {
                 bs_stream.close();
             } catch (IOException e) {
                 // just ignore it...
             }
             bs_stream = null;
         }
         discardBackingStore();
     }

     /**
      * Method makeInputStream
      *
      * @return
      * @throws IOException
      * @throws FileNotFoundException
      */
     protected InputStream makeInputStream()
             throws IOException, FileNotFoundException {
         close();
         if (cache != null) {
             return new ByteArrayInputStream(cache.toByteArray());
         } else if (bs_handle != null) {
             return createBackingStoreInputStream();
         } else {
             return null;
         }
     }

     /**
      * Method finalize
      */
     protected void finalize() {
         discardBuffer();
     }

     /**
      * Method switchToBackingStore
      *
      * @throws IOException
      */
     protected void switchToBackingStore() throws IOException {
         bs_handle = File.createTempFile("Axis", ".msg");
         bs_handle.createNewFile();
         bs_handle.deleteOnExit();
         bs_stream = new FileOutputStream(bs_handle);
         bs_stream.write(cache.toByteArray());
         cache = null;
     }

     /**
      * Method getBackingStoreFileName
      *
      * @throws IOException
      */
     public String getBackingStoreFileName() throws IOException {
         String fileName = null;
         if (bs_handle != null) {
             fileName = bs_handle.getCanonicalPath();
         }
         return fileName;
     }

     /**
      * Method discardBackingStore
      */
     protected void discardBackingStore() {
         if (bs_handle != null) {
             bs_handle.delete();
             bs_handle = null;
         }
     }

     /**
      * Method createBackingStoreInputStream
      *
      * @return
      * @throws FileNotFoundException
      */
     protected InputStream createBackingStoreInputStream()
             throws FileNotFoundException {
         try {
             return new BufferedInputStream(
                     new FileInputStream(bs_handle.getCanonicalPath()));
         } catch (IOException e) {
             throw new FileNotFoundException(bs_handle.getAbsolutePath());
         }
     }

     /**
      * Method toByteArray
      *
      * @return
      * @throws IOException
      */
     public byte[] toByteArray() throws IOException {
         InputStream inp = this.makeInputStream();
         byte[] buf = null;
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         buf = new byte[WORKING_BUFFER_SIZE];
         int len;
         while ((len = inp.read(buf, 0, WORKING_BUFFER_SIZE)) != -1) {
             baos.write(buf, 0, len);
         }
         inp.close();
         discardBackingStore();
         return baos.toByteArray();
     }

     /**
      * Method writeTo
      *
      * @param os
      * @throws IOException
      */
     public void writeTo(OutputStream os) throws IOException {
         InputStream inp = this.makeInputStream();
         byte[] buf = null;
         buf = new byte[WORKING_BUFFER_SIZE];
         int len;
         while ((len = inp.read(buf, 0, WORKING_BUFFER_SIZE)) != -1) {
             os.write(buf, 0, len);
         }
         inp.close();
         discardBackingStore();
     }
 }
	/*
	* 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.
	*/
	package org.apache.axis.utils;

	import org.apache.axis.AxisEngine;
	import org.apache.axis.AxisProperties;

	import java.io.BufferedInputStream;
	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;

	/**
	* Class ByteArray
	*/
	public class ByteArray extends OutputStream {

	protected static double DEFAULT_CACHE_INCREMENT = 2.5;
	protected static int DEFAULT_RESIDENT_SIZE = 512 * 1024 * 1024; // 512 MB
	protected static boolean DEFAULT_ENABLE_BACKING_STORE = true;
	protected static int WORKING_BUFFER_SIZE = 8192;

	protected org.apache.axis.utils.ByteArrayOutputStream cache = null;

	protected int max_size = 0;
	protected File bs_handle = null;
	protected OutputStream bs_stream = null;
	protected long count = 0;
	protected boolean enableBackingStore = DEFAULT_ENABLE_BACKING_STORE;

	public boolean isEnableBackingStore() {
	return enableBackingStore;
	}

	public void setEnableBackingStore(boolean enableBackingStore) {
	this.enableBackingStore = enableBackingStore;
	}

	public static boolean isDEFAULT_ENABLE_BACKING_STORE() {
	return DEFAULT_ENABLE_BACKING_STORE;
	}

	public static void setDEFAULT_ENABLE_BACKING_STORE(
	boolean DEFAULT_ENABLE_BACKING_STORE) {
	ByteArray.DEFAULT_ENABLE_BACKING_STORE = DEFAULT_ENABLE_BACKING_STORE;
	}

	public static int getDEFAULT_RESIDENT_SIZE() {
	return DEFAULT_RESIDENT_SIZE;
	}

	public static void setDEFAULT_RESIDENT_SIZE(int DEFAULT_RESIDENT_SIZE) {
	ByteArray.DEFAULT_RESIDENT_SIZE = DEFAULT_RESIDENT_SIZE;
	}

	public static double getDEFAULT_CACHE_INCREMENT() {
	return DEFAULT_CACHE_INCREMENT;
	}

	public static void setDEFAULT_CACHE_INCREMENT(
	double DEFAULT_CACHE_INCREMENT) {
	ByteArray.DEFAULT_CACHE_INCREMENT = DEFAULT_CACHE_INCREMENT;
	}

	static {
	String value;
	value = AxisProperties.getProperty(
	AxisEngine.PROP_BYTE_BUFFER_CACHE_INCREMENT,
	"" + DEFAULT_CACHE_INCREMENT);
	DEFAULT_CACHE_INCREMENT = Double.parseDouble(value);
	value = AxisProperties.getProperty(
	AxisEngine.PROP_BYTE_BUFFER_RESIDENT_MAX_SIZE,
	"" + DEFAULT_RESIDENT_SIZE);
	DEFAULT_RESIDENT_SIZE = Integer.parseInt(value);
	value = AxisProperties.getProperty(
	AxisEngine.PROP_BYTE_BUFFER_WORK_BUFFER_SIZE,
	"" + WORKING_BUFFER_SIZE);
	WORKING_BUFFER_SIZE = Integer.parseInt(value);
	value =
	AxisProperties.getProperty(AxisEngine.PROP_BYTE_BUFFER_BACKING,
	"" + DEFAULT_ENABLE_BACKING_STORE);
	if (value.equalsIgnoreCase("true") \|\|
	value.equals("1") \|\|
	value.equalsIgnoreCase("yes")) {
	DEFAULT_ENABLE_BACKING_STORE = true;
	} else {
	DEFAULT_ENABLE_BACKING_STORE = false;
	}
	}

	/**
	* Constructor ByteArray
	*/
	public ByteArray() {
	this(DEFAULT_RESIDENT_SIZE);
	}

	/**
	* Constructor ByteArray
	*
	* @param max_resident_size
	*/
	public ByteArray(int max_resident_size) {
	this(0, max_resident_size);
	}

	/**
	* Constructor ByteArray
	*
	* @param probable_size
	* @param max_resident_size
	*/
	public ByteArray(int probable_size, int max_resident_size) {
	if (probable_size > max_resident_size) {
	probable_size = 0;
	}
	if (probable_size < WORKING_BUFFER_SIZE) {
	probable_size = WORKING_BUFFER_SIZE;
	}
	cache = new org.apache.axis.utils.ByteArrayOutputStream(probable_size);
	max_size = max_resident_size;
	}

	/**
	* Method write
	*
	* @param bytes
	* @throws IOException
	*/
	public void write(byte bytes[]) throws IOException {
	write(bytes, 0, bytes.length);
	}

	/**
	* Method write
	*
	* @param bytes
	* @param start
	* @param length
	* @throws IOException
	*/
	public void write(byte bytes[], int start, int length) throws IOException {
	count += length;
	if (cache != null) {
	increaseCapacity(length);
	}
	if (cache != null) {
	cache.write(bytes, start, length);
	} else if (bs_stream != null) {
	bs_stream.write(bytes, start, length);
	} else {
	throw new IOException("ByteArray does not have a backing store!");
	}
	}

	/**
	* Method write
	*
	* @param b
	* @throws IOException
	*/
	public void write(int b) throws IOException {
	count += 1;
	if (cache != null) {
	increaseCapacity(1);
	}
	if (cache != null) {
	cache.write(b);
	} else if (bs_stream != null) {
	bs_stream.write(b);
	} else {
	throw new IOException("ByteArray does not have a backing store!");
	}
	}

	/**
	* Method close
	*
	* @throws IOException
	*/
	public void close() throws IOException {
	if (bs_stream != null) {
	bs_stream.close();
	bs_stream = null;
	}
	}

	/**
	* Method size
	*
	* @return
	*/
	public long size() {
	return count;
	}

	/**
	* Method flush
	*
	* @throws IOException
	*/
	public void flush() throws IOException {
	if (bs_stream != null) {
	bs_stream.flush();
	}
	}

	/**
	* Method increaseCapacity
	*
	* @param count
	* @throws IOException
	*/
	protected void increaseCapacity(int count) throws IOException {
	if (cache == null) {
	return;
	}
	if (count + cache.size() <= max_size) {
	return;
	} else if (enableBackingStore) {
	switchToBackingStore();
	} else {
	throw new IOException("ByteArray can not increase capacity by " +
	count +
	" due to max size limit of " + max_size);
	}
	}

	/**
	* Method discardBuffer
	*/
	public synchronized void discardBuffer() {
	cache = null;
	if (bs_stream != null) {
	try {
	bs_stream.close();
	} catch (IOException e) {
	// just ignore it...
	}
	bs_stream = null;
	}
	discardBackingStore();
	}

	/**
	* Method makeInputStream
	*
	* @return
	* @throws IOException
	* @throws FileNotFoundException
	*/
	protected InputStream makeInputStream()
	throws IOException, FileNotFoundException {
	close();
	if (cache != null) {
	return new ByteArrayInputStream(cache.toByteArray());
	} else if (bs_handle != null) {
	return createBackingStoreInputStream();
	} else {
	return null;
	}
	}

	/**
	* Method finalize
	*/
	protected void finalize() {
	discardBuffer();
	}

	/**
	* Method switchToBackingStore
	*
	* @throws IOException
	*/
	protected void switchToBackingStore() throws IOException {
	bs_handle = File.createTempFile("Axis", ".msg");
	bs_handle.createNewFile();
	bs_handle.deleteOnExit();
	bs_stream = new FileOutputStream(bs_handle);
	bs_stream.write(cache.toByteArray());
	cache = null;
	}

	/**
	* Method getBackingStoreFileName
	*
	* @throws IOException
	*/
	public String getBackingStoreFileName() throws IOException {
	String fileName = null;
	if (bs_handle != null) {
	fileName = bs_handle.getCanonicalPath();
	}
	return fileName;
	}

	/**
	* Method discardBackingStore
	*/
	protected void discardBackingStore() {
	if (bs_handle != null) {
	bs_handle.delete();
	bs_handle = null;
	}
	}

	/**
	* Method createBackingStoreInputStream
	*
	* @return
	* @throws FileNotFoundException
	*/
	protected InputStream createBackingStoreInputStream()
	throws FileNotFoundException {
	try {
	return new BufferedInputStream(
	new FileInputStream(bs_handle.getCanonicalPath()));
	} catch (IOException e) {
	throw new FileNotFoundException(bs_handle.getAbsolutePath());
	}
	}

	/**
	* Method toByteArray
	*
	* @return
	* @throws IOException
	*/
	public byte[] toByteArray() throws IOException {
	InputStream inp = this.makeInputStream();
	byte[] buf = null;
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	buf = new byte[WORKING_BUFFER_SIZE];
	int len;
	while ((len = inp.read(buf, 0, WORKING_BUFFER_SIZE)) != -1) {
	baos.write(buf, 0, len);
	}
	inp.close();
	discardBackingStore();
	return baos.toByteArray();
	}

	/**
	* Method writeTo
	*
	* @param os
	* @throws IOException
	*/
	public void writeTo(OutputStream os) throws IOException {
	InputStream inp = this.makeInputStream();
	byte[] buf = null;
	buf = new byte[WORKING_BUFFER_SIZE];
	int len;
	while ((len = inp.read(buf, 0, WORKING_BUFFER_SIZE)) != -1) {
	os.write(buf, 0, len);
	}
	inp.close();
	discardBackingStore();
	}
	}