Quadcap Embeddable Server

com/quadcap/io/SaveRestoreStream.java

Go to the documentation of this file.

package com.quadcap.io;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

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.InputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * This class implements a simple persistent object which can be written
 * as an OutputStream and read as an InputStream.  Small objects can be
 * stored in memory, larger objects can be stored in temp files on disk.
 *
 * @author Stan Bailes
 */
public class SaveRestoreStream {
    ByteArrayOutputStream       bos             = null;
    FileOutputStream            fos             = null;
    File                        file            = null;
    int                         len             = 0;
    int                         max             = 4096;

    /**
     * Construct a new SaveRestoreStream with the default max buffered
     */
    public SaveRestoreStream() {
    }

    /**
     * Construct a new SaveRestoreStream with the specified max buffered
     * size.
     *
     * @param max the maximum amount of data to be buffered in memory.
     */
    public SaveRestoreStream(int max) {
        this.max = max;
    }

    /**
     * Construct a new SaveRestoreStream using the data in the specified
     * InputStream.
     *
     * @param in the InputStream supplying the data for this stream
     */
    public SaveRestoreStream(InputStream in) throws IOException {
        OutputStream out = getOutputStream();
        try {
            IO.copyStream(in, out);
        } finally {
            out.close();
        }
    }

    /**
     * Return an output stream that the caller can use to save his object
     *
     * @return the output stream
     */
    public OutputStream getOutputStream() throws IOException {
        if (file == null) {
            bos = new ByteArrayOutputStream();
            if (fos != null) fos.close();
            fos = null;
        } else {
            bos = null;
            fos = new FileOutputStream(file);
        }
        
        return new OutputStream() {
            public void write(int c) throws IOException {
                doWrite(c);
            }
            public void flush() throws IOException {
                if (bos != null) bos.flush();
                else fos.flush();
            }
            public void close() throws IOException {
                if (bos != null) {
                    len = bos.size();
                } else if (fos != null) {
                    fos.close();
                    fos = null;
                    len = (int)file.length();
                }
            }
        };
    }

    public int length() {
        return len;
    }

    static int  tmpFileCount    = 0;

    static synchronized File tmpFile() throws IOException {
        return File.createTempFile("" + System.currentTimeMillis() + "." +
                                   (tmpFileCount++), ".tmp");
    }

    /**
     * Write a byte to the stream.
     *
     * @param c the byte
     * @exception IOException may be thrown
     */
    public void doWrite(int c) throws IOException {
        if (bos != null) {
            if (bos.size() < max) {
                bos.write(c);
            } else {
                file = tmpFile();
                fos = new FileOutputStream(file);
                bos.writeTo(fos);
                fos.write(c);
                bos.close();
                bos = null;
            } 
        } else {
            fos.write(c);
        }
    }
                    
    /**
     * Return an input stream that the user can use to get his data back
     *
     * @return the input stream
     */
    public InputStream getInputStream() throws IOException {
        return getInputStream(true);
    }
    
    public InputStream getInputStream(final boolean del) throws IOException {
        if (bos != null) return new ByteArrayInputStream(bos.toByteArray());
        if (fos != null) {
            fos.close();
            fos = null;
        }
        if (file != null) {
            final FileInputStream fis = new FileInputStream(file);
            final File f = file;
            if (del) file = null;
            return new InputStream() {
                public int read() throws IOException {
                    return fis.read();
                }
                public int read(byte[] buf) throws IOException {
                    return fis.read(buf);
                }
                public int read(byte[] buf, int off, int cnt) throws IOException {
                    return fis.read(buf, off, cnt);
                }
                public void close() throws IOException {
                    fis.close();
                    if (del) f.delete();
                }
                public void finalize() {
                    try {
                        close();
                    } catch (Throwable t) {}
                }
            };
        }
        throw new IOException("no data");
    }

    /**
     * Return the data as a string
     */
    public String toString() {
        if (bos != null) return bos.toString();
        if (fos != null) {
            throw new RuntimeException("too large");
        }
        return null;
    }

    public void close() {
        bos = null;
        if (fos != null) {
            try {
                fos.close();
            } catch (Exception e) {
            }
        }
        fos = null;
        if (file != null) {
            try {
                file.delete();
            } catch (Exception e) {
            }
        }
        file = null;
        len = 0;
    }

    public void reset() {
        close();
    }

    public void finalize() {
        close();
    }
}