james-server-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcconn...@apache.org
Subject cvs commit: james-server/src/java/org/apache/james/util/io ClassLoaderObjectInputStream.java ExtensionFileFilter.java IOUtil.java ResettableFileInputStream.java
Date Sun, 18 Jul 2004 05:58:33 GMT
mcconnell    2004/07/17 22:58:33

  Modified:    src/java/org/apache/james/mailrepository/filepair
                        AbstractFileRepository.java
                        File_Persistent_Object_Repository.java
                        File_Persistent_Stream_Repository.java
               src/java/org/apache/james/nntpserver/repository
                        ArticleIDRepository.java NNTPArticleImpl.java
                        NNTPGroupImpl.java NNTPSpooler.java
  Added:       src/java/org/apache/james/util/io
                        ClassLoaderObjectInputStream.java
                        ExtensionFileFilter.java IOUtil.java
                        ResettableFileInputStream.java
  Log:
  Remove the implementation dependencies on store by putting a couple of the old io util classes
into james.util.io and updating references in the james sources.
  
  Revision  Changes    Path
  1.9       +1 -1      james-server/src/java/org/apache/james/mailrepository/filepair/AbstractFileRepository.java
  
  Index: AbstractFileRepository.java
  ===================================================================
  RCS file: /home/cvs/james-server/src/java/org/apache/james/mailrepository/filepair/AbstractFileRepository.java,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- AbstractFileRepository.java	9 Jul 2004 03:07:12 -0000	1.8
  +++ AbstractFileRepository.java	18 Jul 2004 05:58:33 -0000	1.9
  @@ -34,7 +34,7 @@
   import java.util.ArrayList;
   import java.util.Iterator;
   import org.apache.avalon.cornerstone.services.store.Repository;
  -import org.apache.avalon.cornerstone.blocks.masterstore.ExtensionFileFilter;
  +import org.apache.james.util.io.ExtensionFileFilter;
   import org.apache.avalon.framework.activity.Initializable;
   import org.apache.avalon.framework.configuration.Configurable;
   import org.apache.avalon.framework.configuration.Configuration;
  
  
  
  1.8       +1 -1      james-server/src/java/org/apache/james/mailrepository/filepair/File_Persistent_Object_Repository.java
  
  Index: File_Persistent_Object_Repository.java
  ===================================================================
  RCS file: /home/cvs/james-server/src/java/org/apache/james/mailrepository/filepair/File_Persistent_Object_Repository.java,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -r1.7 -r1.8
  --- File_Persistent_Object_Repository.java	9 Jul 2004 03:09:05 -0000	1.7
  +++ File_Persistent_Object_Repository.java	18 Jul 2004 05:58:33 -0000	1.8
  @@ -29,7 +29,7 @@
   import java.io.ObjectOutputStream;
   import java.io.OutputStream;
   import org.apache.avalon.cornerstone.services.store.ObjectRepository;
  -import org.apache.avalon.cornerstone.blocks.masterstore.ClassLoaderObjectInputStream;
  +import org.apache.james.util.io.ClassLoaderObjectInputStream;
   
   /**
    * This is a simple implementation of persistent object store using
  
  
  
  1.10      +1 -1      james-server/src/java/org/apache/james/mailrepository/filepair/File_Persistent_Stream_Repository.java
  
  Index: File_Persistent_Stream_Repository.java
  ===================================================================
  RCS file: /home/cvs/james-server/src/java/org/apache/james/mailrepository/filepair/File_Persistent_Stream_Repository.java,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- File_Persistent_Stream_Repository.java	9 Jul 2004 03:34:00 -0000	1.9
  +++ File_Persistent_Stream_Repository.java	18 Jul 2004 05:58:33 -0000	1.10
  @@ -31,7 +31,7 @@
   import java.util.ArrayList;
   import java.util.HashMap;
   import org.apache.avalon.cornerstone.services.store.StreamRepository;
  -import org.apache.avalon.cornerstone.blocks.masterstore.IOUtil;
  +import org.apache.james.util.io.IOUtil;
   
   /**
    * Implementation of a StreamRepository to a File.
  
  
  
  1.18      +1 -1      james-server/src/java/org/apache/james/nntpserver/repository/ArticleIDRepository.java
  
  Index: ArticleIDRepository.java
  ===================================================================
  RCS file: /home/cvs/james-server/src/java/org/apache/james/nntpserver/repository/ArticleIDRepository.java,v
  retrieving revision 1.17
  retrieving revision 1.18
  diff -u -r1.17 -r1.18
  --- ArticleIDRepository.java	9 Jul 2004 03:36:13 -0000	1.17
  +++ ArticleIDRepository.java	18 Jul 2004 05:58:33 -0000	1.18
  @@ -17,7 +17,7 @@
   
   package org.apache.james.nntpserver.repository;
   
  -import org.apache.avalon.cornerstone.blocks.masterstore.IOUtil;
  +import org.apache.james.util.io.IOUtil;
   import org.apache.james.util.Base64;
   
   import java.io.File;
  
  
  
  1.25      +1 -1      james-server/src/java/org/apache/james/nntpserver/repository/NNTPArticleImpl.java
  
  Index: NNTPArticleImpl.java
  ===================================================================
  RCS file: /home/cvs/james-server/src/java/org/apache/james/nntpserver/repository/NNTPArticleImpl.java,v
  retrieving revision 1.24
  retrieving revision 1.25
  diff -u -r1.24 -r1.25
  --- NNTPArticleImpl.java	9 Jul 2004 03:36:13 -0000	1.24
  +++ NNTPArticleImpl.java	18 Jul 2004 05:58:33 -0000	1.25
  @@ -26,7 +26,7 @@
   
   import javax.mail.internet.InternetHeaders;
   
  -import org.apache.avalon.cornerstone.blocks.masterstore.IOUtil;
  +import org.apache.james.util.io.IOUtil;
   import org.apache.james.core.MailHeaders;
   import org.apache.james.nntpserver.NNTPException;
   
  
  
  
  1.17      +2 -2      james-server/src/java/org/apache/james/nntpserver/repository/NNTPGroupImpl.java
  
  Index: NNTPGroupImpl.java
  ===================================================================
  RCS file: /home/cvs/james-server/src/java/org/apache/james/nntpserver/repository/NNTPGroupImpl.java,v
  retrieving revision 1.16
  retrieving revision 1.17
  diff -u -r1.16 -r1.17
  --- NNTPGroupImpl.java	9 Jul 2004 03:36:13 -0000	1.16
  +++ NNTPGroupImpl.java	18 Jul 2004 05:58:33 -0000	1.17
  @@ -20,8 +20,8 @@
   import org.apache.james.util.io.AndFileFilter;
   import org.apache.james.util.io.InvertedFileFilter;
   
  -import org.apache.avalon.cornerstone.blocks.masterstore.ExtensionFileFilter;
  -import org.apache.avalon.cornerstone.blocks.masterstore.IOUtil;
  +import org.apache.james.util.io.ExtensionFileFilter;
  +import org.apache.james.util.io.IOUtil;
   import org.apache.avalon.framework.logger.AbstractLogEnabled;
   import org.apache.james.nntpserver.DateSinceFileFilter;
   
  
  
  
  1.24      +1 -1      james-server/src/java/org/apache/james/nntpserver/repository/NNTPSpooler.java
  
  Index: NNTPSpooler.java
  ===================================================================
  RCS file: /home/cvs/james-server/src/java/org/apache/james/nntpserver/repository/NNTPSpooler.java,v
  retrieving revision 1.23
  retrieving revision 1.24
  diff -u -r1.23 -r1.24
  --- NNTPSpooler.java	9 Jul 2004 03:36:13 -0000	1.23
  +++ NNTPSpooler.java	18 Jul 2004 05:58:33 -0000	1.24
  @@ -27,7 +27,7 @@
   
   import javax.mail.internet.MimeMessage;
   
  -import org.apache.avalon.cornerstone.blocks.masterstore.IOUtil;
  +import org.apache.james.util.io.IOUtil;
   import org.apache.avalon.framework.activity.Initializable;
   import org.apache.avalon.framework.configuration.Configurable;
   import org.apache.avalon.framework.configuration.Configuration;
  
  
  
  1.1                  james-server/src/java/org/apache/james/util/io/ClassLoaderObjectInputStream.java
  
  Index: ClassLoaderObjectInputStream.java
  ===================================================================
  /* 
   * Copyright 1999-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.james.util.io;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.ObjectInputStream;
  import java.io.ObjectStreamClass;
  import java.io.StreamCorruptedException;
  
  /**
   * A special ObjectInputStream to handle highly transient classes hosted
   * by Avalon components that are juggling many classloaders.
   *
   * @author <a href="mailto:paul_hammant@yahoo.com">Paul Hammant</a>
   * @version $Revision: 1.1 $ $Date: 2004/07/18 05:58:33 $
   */
  public class ClassLoaderObjectInputStream
      extends ObjectInputStream
  {
      private ClassLoader m_classLoader;
  
      public ClassLoaderObjectInputStream( final ClassLoader classLoader,
                                           final InputStream inputStream )
          throws IOException, StreamCorruptedException
      {
          super( inputStream );
          m_classLoader = classLoader;
      }
  
      protected Class resolveClass( final ObjectStreamClass objectStreamClass )
          throws IOException, ClassNotFoundException
      {
          final Class clazz =
              Class.forName( objectStreamClass.getName(), false, m_classLoader );
  
          if( null != clazz )
          {
              return clazz; // the classloader knows of the class
          }
          else
          {
              // classloader knows not of class, let the super classloader do it
              return super.resolveClass( objectStreamClass );
          }
      }
  }
  
  
  
  1.1                  james-server/src/java/org/apache/james/util/io/ExtensionFileFilter.java
  
  Index: ExtensionFileFilter.java
  ===================================================================
  /* 
   * Copyright 1999-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.james.util.io;
  
  import java.io.File;
  import java.io.FilenameFilter;
  
  /**
   * This filters files based on the extension (what the filename
   * ends with). This is used in retrieving all the files of a
   * particular type.
   *
   * <p>Eg., to retrieve and print all <code>*.java</code> files in the
current directory:</p>
   *
   * <pre>
   * File dir = new File(".");
   * String[] files = dir.list( new ExtensionFileFilter( new String[]{"java"} ) );
   * for (int i=0; i&lt;files.length; i++)
   * {
   *     System.out.println(files[i]);
   * }
   * </pre>
   *
   * @author  Federico Barbieri <fede@apache.org>
   * @author Serge Knystautas <sergek@lokitech.com>
   * @author Peter Donald
   * @version CVS $Revision: 1.1 $ $Date: 2004/07/18 05:58:33 $
   * @since 4.0
   */
  public class ExtensionFileFilter
      implements FilenameFilter
  {
      private String[] m_extensions;
  
      public ExtensionFileFilter( final String[] extensions )
      {
          m_extensions = extensions;
      }
  
      public ExtensionFileFilter( final String extension )
      {
          m_extensions = new String[]{extension};
      }
  
      public boolean accept( final File file, final String name )
      {
          for( int i = 0; i < m_extensions.length; i++ )
          {
              if( name.endsWith( m_extensions[ i ] ) )
              {
                  return true;
              }
          }
          return false;
      }
  }
  
  
  
  
  
  1.1                  james-server/src/java/org/apache/james/util/io/IOUtil.java
  
  Index: IOUtil.java
  ===================================================================
  /* 
   * Copyright 1999-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.james.util.io;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.Reader;
  import java.io.StringReader;
  import java.io.StringWriter;
  import java.io.Writer;
  
  /**
   * General IO Stream manipulation.
   * <p>
   * This class provides static utility methods for input/output operations, particularly
buffered
   * copying between sources (<code>InputStream</code>, <code>Reader</code>,
<code>String</code> and
   * <code>byte[]</code>) and destinations (<code>OutputStream</code>,
<code>Writer</code>,
   * <code>String</code> and <code>byte[]</code>).
   * </p>
   *
   * <p>Unless otherwise noted, these <code>copy</code> methods do <em>not</em>
flush or close the
   * streams. Often, doing so would require making non-portable assumptions about the streams'
origin
   * and further use. This means that both streams' <code>close()</code> methods
must be called after
   * copying. if one omits this step, then the stream resources (sockets, file descriptors)
are
   * released when the associated Stream is garbage-collected. It is not a good idea to rely
on this
   * mechanism. For a good overview of the distinction between "memory management" and "resource
   * management", see <a href="http://www.unixreview.com/articles/1998/9804/9804ja/ja.htm">this
   * UnixReview article</a></p>
   *
   * <p>For each <code>copy</code> method, a variant is provided that allows
the caller to specify the
   * buffer size (the default is 4k). As the buffer size can have a fairly large impact on
speed, this
   * may be worth tweaking. Often "large buffer -&gt; faster" does not hold, even for
large data
   * transfers.</p>
   *
   * <p>For byte-to-char methods, a <code>copy</code> variant allows the
encoding to be selected
   * (otherwise the platform default is used).</p>
   *
   * <p>The <code>copy</code> methods use an internal buffer when copying.
It is therefore advisable
   * <em>not</em> to deliberately wrap the stream arguments to the <code>copy</code>
methods in
   * <code>Buffered*</code> streams. For example, don't do the
   * following:</p>
   *
   * <code>copy( new BufferedInputStream( in ), new BufferedOutputStream( out ) );</code>
   *
   * <p>The rationale is as follows:</p>
   *
   * <p>Imagine that an InputStream's read() is a very expensive operation, which would
usually suggest
   * wrapping in a BufferedInputStream. The BufferedInputStream works by issuing infrequent
   * {@link java.io.InputStream#read(byte[] b, int off, int len)} requests on the underlying
InputStream, to
   * fill an internal buffer, from which further <code>read</code> requests can
inexpensively get
   * their data (until the buffer runs out).</p>
   * <p>However, the <code>copy</code> methods do the same thing, keeping
an internal buffer,
   * populated by {@link InputStream#read(byte[] b, int off, int len)} requests. Having two
buffers
   * (or three if the destination stream is also buffered) is pointless, and the unnecessary
buffer
   * management hurts performance slightly (about 3%, according to some simple experiments).</p>
   *
   * @author Peter Donald
   * @author <a href="mailto:jefft@apache.org">Jeff Turner</a>
   * @version CVS $Revision: 1.1 $ $Date: 2004/07/18 05:58:33 $
   * @since 4.0
   */
  
  /*
   * Behold, intrepid explorers; a map of this class:
   *
   *       Method      Input               Output          Dependency
   *       ------      -----               ------          -------
   * 1     copy        InputStream         OutputStream    (primitive)
   * 2     copy        Reader              Writer          (primitive)
   *
   * 3     copy        InputStream         Writer          2
   * 4     toString    InputStream         String          3
   * 5     toByteArray InputStream         byte[]          1
   *
   * 6     copy        Reader              OutputStream    2
   * 7     toString    Reader              String          2
   * 8     toByteArray Reader              byte[]          6
   *
   * 9     copy        String              OutputStream    2
   * 10    copy        String              Writer          (trivial)
   * 11    toByteArray String              byte[]          9
   *
   * 12    copy        byte[]              Writer          3
   * 13    toString    byte[]              String          12
   * 14    copy        byte[]              OutputStream    (trivial)
   *
   *
   * Note that only the first two methods shuffle bytes; the rest use these two, or (if possible)
copy
   * using native Java copy methods. As there are method variants to specify buffer size and
encoding,
   * each row may correspond to up to 4 methods.
   *
   */
  
  public final class IOUtil
  {
      private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
  
      /**
       * Private constructor to prevent instantiation.
       */
      private IOUtil()
      {
      }
  
      /**
       * Unconditionally close an <code>Reader</code>.
       * Equivalent to {@link Reader#close()}, except any exceptions will be ignored.
       *
       * @param input A (possibly null) Reader
       */
      public static void shutdownReader( final Reader input )
      {
          if( null == input )
          {
              return;
          }
  
          try
          {
              input.close();
          }
          catch( final IOException ioe )
          {
          }
      }
  
      /**
       * Unconditionally close an <code>Writer</code>.
       * Equivalent to {@link Writer#close()}, except any exceptions will be ignored.
       *
       * @param output A (possibly null) Writer
       */
      public static void shutdownWriter( final Writer output )
      {
          if( null == output )
          {
              return;
          }
  
          try
          {
              output.close();
          }
          catch( final IOException ioe )
          {
          }
      }
  
      /**
       * Unconditionally close an <code>OutputStream</code>.
       * Equivalent to {@link OutputStream#close()}, except any exceptions will be ignored.
       * @param output A (possibly null) OutputStream
       */
      public static void shutdownStream( final OutputStream output )
      {
          if( null == output )
          {
              return;
          }
  
          try
          {
              output.close();
          }
          catch( final IOException ioe )
          {
          }
      }
  
      /**
       * Unconditionally close an <code>InputStream</code>.
       * Equivalent to {@link InputStream#close()}, except any exceptions will be ignored.
       * @param input A (possibly null) InputStream
       */
      public static void shutdownStream( final InputStream input )
      {
          if( null == input )
          {
              return;
          }
  
          try
          {
              input.close();
          }
          catch( final IOException ioe )
          {
          }
      }
  
      ///////////////////////////////////////////////////////////////
      // Core copy methods
      ///////////////////////////////////////////////////////////////
  
      /**
       * Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>.
       */
      public static void copy( final InputStream input, final OutputStream output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final InputStream input,
                               final OutputStream output,
                               final int bufferSize )
          throws IOException
      {
          final byte[] buffer = new byte[ bufferSize ];
          int n = 0;
          while( -1 != ( n = input.read( buffer ) ) )
          {
              output.write( buffer, 0, n );
          }
      }
  
      /**
       * Copy chars from a <code>Reader</code> to a <code>Writer</code>.
       */
      public static void copy( final Reader input, final Writer output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy chars from a <code>Reader</code> to a <code>Writer</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final Reader input, final Writer output, final int bufferSize
)
          throws IOException
      {
          final char[] buffer = new char[ bufferSize ];
          int n = 0;
          while( -1 != ( n = input.read( buffer ) ) )
          {
              output.write( buffer, 0, n );
          }
      }
  
      ///////////////////////////////////////////////////////////////
      // Derived copy methods
      // InputStream -> *
      ///////////////////////////////////////////////////////////////
  
  
      ///////////////////////////////////////////////////////////////
      // InputStream -> Writer
  
      /**
       * Copy and convert bytes from an <code>InputStream</code> to chars on a
       * <code>Writer</code>.
       * The platform's default encoding is used for the byte-to-char conversion.
       */
      public static void copy( final InputStream input, final Writer output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy and convert bytes from an <code>InputStream</code> to chars on a
       * <code>Writer</code>.
       * The platform's default encoding is used for the byte-to-char conversion.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final InputStream input, final Writer output, final int bufferSize
)
          throws IOException
      {
          final InputStreamReader in = new InputStreamReader( input );
          copy( in, output, bufferSize );
      }
  
      /**
       * Copy and convert bytes from an <code>InputStream</code> to chars on a
       * <code>Writer</code>, using the specified encoding.
       * @param encoding The name of a supported character encoding. See the
       * <a href="http://www.iana.org/assignments/character-sets">IANA
       * Charset Registry</a> for a list of valid encoding types.
       */
      public static void copy( final InputStream input, final Writer output, final String
encoding )
          throws IOException
      {
          final InputStreamReader in = new InputStreamReader( input, encoding );
          copy( in, output );
      }
  
      /**
       * Copy and convert bytes from an <code>InputStream</code> to chars on a
       * <code>Writer</code>, using the specified encoding.
       * @param encoding The name of a supported character encoding. See the
       *        <a href="http://www.iana.org/assignments/character-sets">IANA
       *        Charset Registry</a> for a list of valid encoding types.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final InputStream input,
                               final Writer output,
                               final String encoding,
                               final int bufferSize )
          throws IOException
      {
          final InputStreamReader in = new InputStreamReader( input, encoding );
          copy( in, output, bufferSize );
      }
  
  
      ///////////////////////////////////////////////////////////////
      // InputStream -> String
  
      /**
       * Get the contents of an <code>InputStream</code> as a String.
       * The platform's default encoding is used for the byte-to-char conversion.
       */
      public static String toString( final InputStream input )
          throws IOException
      {
          return toString( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of an <code>InputStream</code> as a String.
       * The platform's default encoding is used for the byte-to-char conversion.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final InputStream input, final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, bufferSize );
          return sw.toString();
      }
  
      /**
       * Get the contents of an <code>InputStream</code> as a String.
       * @param encoding The name of a supported character encoding. See the
       *    <a href="http://www.iana.org/assignments/character-sets">IANA
       *    Charset Registry</a> for a list of valid encoding types.
       */
      public static String toString( final InputStream input, final String encoding )
          throws IOException
      {
          return toString( input, encoding, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of an <code>InputStream</code> as a String.
       * @param encoding The name of a supported character encoding. See the
       *   <a href="http://www.iana.org/assignments/character-sets">IANA
       *   Charset Registry</a> for a list of valid encoding types.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final InputStream input,
                                     final String encoding,
                                     final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, encoding, bufferSize );
          return sw.toString();
      }
  
      ///////////////////////////////////////////////////////////////
      // InputStream -> byte[]
  
      /**
       * Get the contents of an <code>InputStream</code> as a <code>byte[]</code>.
       */
      public static byte[] toByteArray( final InputStream input )
          throws IOException
      {
          return toByteArray( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of an <code>InputStream</code> as a <code>byte[]</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static byte[] toByteArray( final InputStream input, final int bufferSize )
          throws IOException
      {
          final ByteArrayOutputStream output = new ByteArrayOutputStream();
          copy( input, output, bufferSize );
          return output.toByteArray();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // Derived copy methods
      // Reader -> *
      ///////////////////////////////////////////////////////////////
  
      ///////////////////////////////////////////////////////////////
      // Reader -> OutputStream
      /**
       * Serialize chars from a <code>Reader</code> to bytes on an <code>OutputStream</code>,
and
       * flush the <code>OutputStream</code>.
       */
      public static void copy( final Reader input, final OutputStream output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Serialize chars from a <code>Reader</code> to bytes on an <code>OutputStream</code>,
and
       * flush the <code>OutputStream</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final Reader input, final OutputStream output, final int bufferSize
)
          throws IOException
      {
          final OutputStreamWriter out = new OutputStreamWriter( output );
          copy( input, out, bufferSize );
          // NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush
          // here.
          out.flush();
      }
  
      ///////////////////////////////////////////////////////////////
      // Reader -> String
      /**
       * Get the contents of a <code>Reader</code> as a String.
       */
      public static String toString( final Reader input )
          throws IOException
      {
          return toString( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>Reader</code> as a String.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final Reader input, final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, bufferSize );
          return sw.toString();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // Reader -> byte[]
      /**
       * Get the contents of a <code>Reader</code> as a <code>byte[]</code>.
       */
      public static byte[] toByteArray( final Reader input )
          throws IOException
      {
          return toByteArray( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>Reader</code> as a <code>byte[]</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static byte[] toByteArray( final Reader input, final int bufferSize )
          throws IOException
      {
          ByteArrayOutputStream output = new ByteArrayOutputStream();
          copy( input, output, bufferSize );
          return output.toByteArray();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // Derived copy methods
      // String -> *
      ///////////////////////////////////////////////////////////////
  
  
      ///////////////////////////////////////////////////////////////
      // String -> OutputStream
  
      /**
       * Serialize chars from a <code>String</code> to bytes on an <code>OutputStream</code>,
and
       * flush the <code>OutputStream</code>.
       */
      public static void copy( final String input, final OutputStream output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Serialize chars from a <code>String</code> to bytes on an <code>OutputStream</code>,
and
       * flush the <code>OutputStream</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final String input, final OutputStream output, final int bufferSize
)
          throws IOException
      {
          final StringReader in = new StringReader( input );
          final OutputStreamWriter out = new OutputStreamWriter( output );
          copy( in, out, bufferSize );
          // NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush
          // here.
          out.flush();
      }
  
  
  
      ///////////////////////////////////////////////////////////////
      // String -> Writer
  
      /**
       * Copy chars from a <code>String</code> to a <code>Writer</code>.
       */
      public static void copy( final String input, final Writer output )
          throws IOException
      {
          output.write( input );
      }
  
      /**
       * Copy bytes from an <code>InputStream</code> to an
       * <code>OutputStream</code>, with buffering.
       * This is equivalent to passing a
       * {@link java.io.BufferedInputStream} and
       * {@link java.io.BufferedOutputStream} to {@link #copy(InputStream, OutputStream)},
       * and flushing the output stream afterwards. The streams are not closed
       * after the copy.
       * @deprecated Buffering streams is actively harmful! See the class description as to
why. Use
       * {@link #copy(InputStream, OutputStream)} instead.
       */
      public static void bufferedCopy( final InputStream input, final OutputStream output
)
          throws IOException
      {
          final BufferedInputStream in = new BufferedInputStream( input );
          final BufferedOutputStream out = new BufferedOutputStream( output );
          copy( in, out );
          out.flush();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // String -> byte[]
      /**
       * Get the contents of a <code>String</code> as a <code>byte[]</code>.
       */
      public static byte[] toByteArray( final String input )
          throws IOException
      {
          return toByteArray( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>String</code> as a <code>byte[]</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static byte[] toByteArray( final String input, final int bufferSize )
          throws IOException
      {
          ByteArrayOutputStream output = new ByteArrayOutputStream();
          copy( input, output, bufferSize );
          return output.toByteArray();
      }
  
  
  
      ///////////////////////////////////////////////////////////////
      // Derived copy methods
      // byte[] -> *
      ///////////////////////////////////////////////////////////////
  
  
      ///////////////////////////////////////////////////////////////
      // byte[] -> Writer
  
      /**
       * Copy and convert bytes from a <code>byte[]</code> to chars on a
       * <code>Writer</code>.
       * The platform's default encoding is used for the byte-to-char conversion.
       */
      public static void copy( final byte[] input, final Writer output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy and convert bytes from a <code>byte[]</code> to chars on a
       * <code>Writer</code>.
       * The platform's default encoding is used for the byte-to-char conversion.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final byte[] input, final Writer output, final int bufferSize
)
          throws IOException
      {
          final ByteArrayInputStream in = new ByteArrayInputStream( input );
          copy( in, output, bufferSize );
      }
  
      /**
       * Copy and convert bytes from a <code>byte[]</code> to chars on a
       * <code>Writer</code>, using the specified encoding.
       * @param encoding The name of a supported character encoding. See the
       * <a href="http://www.iana.org/assignments/character-sets">IANA
       * Charset Registry</a> for a list of valid encoding types.
       */
      public static void copy( final byte[] input, final Writer output, final String encoding
)
          throws IOException
      {
          final ByteArrayInputStream in = new ByteArrayInputStream( input );
          copy( in, output, encoding );
      }
  
      /**
       * Copy and convert bytes from a <code>byte[]</code> to chars on a
       * <code>Writer</code>, using the specified encoding.
       * @param encoding The name of a supported character encoding. See the
       *        <a href="http://www.iana.org/assignments/character-sets">IANA
       *        Charset Registry</a> for a list of valid encoding types.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final byte[] input,
                               final Writer output,
                               final String encoding,
                               final int bufferSize )
          throws IOException
      {
          final ByteArrayInputStream in = new ByteArrayInputStream( input );
          copy( in, output, encoding, bufferSize );
      }
  
  
      ///////////////////////////////////////////////////////////////
      // byte[] -> String
  
      /**
       * Get the contents of a <code>byte[]</code> as a String.
       * The platform's default encoding is used for the byte-to-char conversion.
       */
      public static String toString( final byte[] input )
          throws IOException
      {
          return toString( input, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>byte[]</code> as a String.
       * The platform's default encoding is used for the byte-to-char conversion.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final byte[] input, final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, bufferSize );
          return sw.toString();
      }
  
      /**
       * Get the contents of a <code>byte[]</code> as a String.
       * @param encoding The name of a supported character encoding. See the
       *    <a href="http://www.iana.org/assignments/character-sets">IANA
       *    Charset Registry</a> for a list of valid encoding types.
       */
      public static String toString( final byte[] input, final String encoding )
          throws IOException
      {
          return toString( input, encoding, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Get the contents of a <code>byte[]</code> as a String.
       * @param encoding The name of a supported character encoding. See the
       *   <a href="http://www.iana.org/assignments/character-sets">IANA
       *   Charset Registry</a> for a list of valid encoding types.
       * @param bufferSize Size of internal buffer to use.
       */
      public static String toString( final byte[] input,
                                     final String encoding,
                                     final int bufferSize )
          throws IOException
      {
          final StringWriter sw = new StringWriter();
          copy( input, sw, encoding, bufferSize );
          return sw.toString();
      }
  
  
      ///////////////////////////////////////////////////////////////
      // byte[] -> OutputStream
  
      /**
       * Copy bytes from a <code>byte[]</code> to an <code>OutputStream</code>.
       */
      public static void copy( final byte[] input, final OutputStream output )
          throws IOException
      {
          copy( input, output, DEFAULT_BUFFER_SIZE );
      }
  
      /**
       * Copy bytes from a <code>byte[]</code> to an <code>OutputStream</code>.
       * @param bufferSize Size of internal buffer to use.
       */
      public static void copy( final byte[] input,
                               final OutputStream output,
                               final int bufferSize )
          throws IOException
      {
          output.write( input );
      }
  
      /**
       * Compare the contents of two Streams to determine if they are equal or not.
       *
       * @param input1 the first stream
       * @param input2 the second stream
       * @return true if the content of the streams are equal or they both don't exist, false
otherwise
       */
      public static boolean contentEquals( final InputStream input1,
                                           final InputStream input2 )
          throws IOException
      {
          final InputStream bufferedInput1 = new BufferedInputStream( input1 );
          final InputStream bufferedInput2 = new BufferedInputStream( input2 );
  
          int ch = bufferedInput1.read();
          while( -1 != ch )
          {
              final int ch2 = bufferedInput2.read();
              if( ch != ch2 )
              {
                  return false;
              }
              ch = bufferedInput1.read();
          }
  
          final int ch2 = bufferedInput2.read();
          if( -1 != ch2 )
          {
              return false;
          }
          else
          {
              return true;
          }
      }
  }
  
  
  
  1.1                  james-server/src/java/org/apache/james/util/io/ResettableFileInputStream.java
  
  Index: ResettableFileInputStream.java
  ===================================================================
  /* 
   * Copyright 1999-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.james.util.io;
  
  import java.io.BufferedInputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  
  /**
   * @author  Federico Barbieri <fede@apache.org>
   */
  public class ResettableFileInputStream
      extends InputStream
  {
      protected static final int DEFAULT_BUFFER_SIZE = 1024;
  
      protected final String m_filename;
      protected int m_bufferSize;
      protected InputStream m_inputStream;
      protected long m_position;
      protected long m_mark;
      protected boolean m_isMarkSet;
  
      public ResettableFileInputStream( final File file )
          throws IOException
      {
          this( file.getCanonicalPath() );
      }
  
      public ResettableFileInputStream( final String filename )
          throws IOException
      {
          this( filename, DEFAULT_BUFFER_SIZE );
      }
  
      public ResettableFileInputStream( final String filename, final int bufferSize )
          throws IOException
      {
          m_bufferSize = bufferSize;
          m_filename = filename;
          m_position = 0;
  
          m_inputStream = newStream();
      }
  
      public void mark( final int readLimit )
      {
          m_isMarkSet = true;
          m_mark = m_position;
          m_inputStream.mark( readLimit );
      }
  
      public boolean markSupported()
      {
          return true;
      }
  
      public void reset()
          throws IOException
      {
          if( !m_isMarkSet )
          {
              throw new IOException( "Unmarked Stream" );
          }
          try
          {
              m_inputStream.reset();
          }
          catch( final IOException ioe )
          {
              try
              {
                  m_inputStream.close();
                  m_inputStream = newStream();
                  m_inputStream.skip( m_mark );
                  m_position = m_mark;
              }
              catch( final Exception e )
              {
                  throw new IOException( "Cannot reset current Stream: " + e.getMessage()
);
              }
          }
      }
  
      protected InputStream newStream()
          throws IOException
      {
          return new BufferedInputStream( new FileInputStream( m_filename ), m_bufferSize
);
      }
  
      public int available()
          throws IOException
      {
          return m_inputStream.available();
      }
  
      public void close() throws IOException
      {
          m_inputStream.close();
      }
  
      public int read() throws IOException
      {
          m_position++;
          return m_inputStream.read();
      }
  
      public int read( final byte[] bytes, final int offset, final int length )
          throws IOException
      {
          final int count = m_inputStream.read( bytes, offset, length );
          m_position += count;
          return count;
      }
  
      public long skip( final long count )
          throws IOException
      {
          m_position += count;
          return m_inputStream.skip( count );
      }
  }
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscribe@james.apache.org
For additional commands, e-mail: server-dev-help@james.apache.org


Mime
View raw message