ojluni/src/main/java/javax/swing/text/rtf/AbstractFilter.java - platform/libcore.git - Git at Google

 /*
  * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package javax.swing.text.rtf;

 import java.io.*;
 import java.lang.*;

 /**
  * A generic superclass for streams which read and parse text
  * consisting of runs of characters interspersed with occasional
  * ``specials'' (formatting characters).
  *
  * <p> Most of the functionality
  * of this class would be redundant except that the
  * <code>ByteToChar</code> converters
  * are suddenly private API. Presumably this class will disappear
  * when the API is made public again. (sigh) That will also let us handle
  * multibyte character sets...
  *
  * <P> A subclass should override at least <code>write(char)</code>
  * and <code>writeSpecial(int)</code>. For efficiency's sake it's a
  * good idea to override <code>write(String)</code> as well. The subclass'
  * initializer may also install appropriate translation and specials tables.
  *
  * @see OutputStream
  */
 abstract class AbstractFilter extends OutputStream
 {
     /** A table mapping bytes to characters */
     protected char translationTable[];
     /** A table indicating which byte values should be interpreted as
      *  characters and which should be treated as formatting codes */
     protected boolean specialsTable[];

     /** A translation table which does ISO Latin-1 (trivial) */
     static final char latin1TranslationTable[];
     /** A specials table which indicates that no characters are special */
     static final boolean noSpecialsTable[];
     /** A specials table which indicates that all characters are special */
     static final boolean allSpecialsTable[];

     static {
       int i;

       noSpecialsTable = new boolean[256];
       for (i = 0; i < 256; i++)
         noSpecialsTable[i] = false;

       allSpecialsTable = new boolean[256];
       for (i = 0; i < 256; i++)
         allSpecialsTable[i] = true;

       latin1TranslationTable = new char[256];
       for (i = 0; i < 256; i++)
         latin1TranslationTable[i] = (char)i;
     }

     /**
      * A convenience method that reads text from a FileInputStream
      * and writes it to the receiver.
      * The format in which the file
      * is read is determined by the concrete subclass of
      * AbstractFilter to which this method is sent.
      * <p>This method does not close the receiver after reaching EOF on
      * the input stream.
      * The user must call <code>close()</code> to ensure that all
      * data are processed.
      *
      * @param in      An InputStream providing text.
      */
     public void readFromStream(InputStream in)
       throws IOException
     {
         byte buf[];
         int count;

         buf = new byte[16384];

         while(true) {
             count = in.read(buf);
             if (count < 0)
                 break;

             this.write(buf, 0, count);
         }
     }

     public void readFromReader(Reader in)
       throws IOException
     {
         char buf[];
         int count;

         buf = new char[2048];

         while(true) {
             count = in.read(buf);
             if (count < 0)
                 break;
             for (int i = 0; i < count; i++) {
               this.write(buf[i]);
             }
         }
     }

     public AbstractFilter()
     {
         translationTable = latin1TranslationTable;
         specialsTable = noSpecialsTable;
     }

     /**
      * Implements the abstract method of OutputStream, of which this class
      * is a subclass.
      */
     public void write(int b)
       throws IOException
     {
       if (b < 0)
         b += 256;
       if (specialsTable[b])
         writeSpecial(b);
       else {
         char ch = translationTable[b];
         if (ch != (char)0)
           write(ch);
       }
     }

     /**
      * Implements the buffer-at-a-time write method for greater
      * efficiency.
      *
      * <p> <strong>PENDING:</strong> Does <code>write(byte[])</code>
      * call <code>write(byte[], int, int)</code> or is it the other way
      * around?
      */
     public void write(byte[] buf, int off, int len)
       throws IOException
     {
       StringBuilder accumulator = null;
       while (len > 0) {
         short b = (short)buf[off];

         // stupid signed bytes
         if (b < 0)
             b += 256;

         if (specialsTable[b]) {
           if (accumulator != null) {
             write(accumulator.toString());
             accumulator = null;
           }
           writeSpecial(b);
         } else {
           char ch = translationTable[b];
           if (ch != (char)0) {
             if (accumulator == null)
               accumulator = new StringBuilder();
             accumulator.append(ch);
           }
         }

         len --;
         off ++;
       }

       if (accumulator != null)
         write(accumulator.toString());
     }

     /**
      * Hopefully, all subclasses will override this method to accept strings
      * of text, but if they don't, AbstractFilter's implementation
      * will spoon-feed them via <code>write(char)</code>.
      *
      * @param s The string of non-special characters written to the
      *          OutputStream.
      */
     public void write(String s)
       throws IOException
     {
       int index, length;

       length = s.length();
       for(index = 0; index < length; index ++) {
         write(s.charAt(index));
       }
     }

     /**
      * Subclasses must provide an implementation of this method which
      * accepts a single (non-special) character.
      *
      * @param ch The character written to the OutputStream.
      */
     protected abstract void write(char ch) throws IOException;

     /**
      * Subclasses must provide an implementation of this method which
      * accepts a single special byte. No translation is performed
      * on specials.
      *
      * @param b The byte written to the OutputStream.
      */
     protected abstract void writeSpecial(int b) throws IOException;
 }
	/*
	* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package javax.swing.text.rtf;

	import java.io.*;
	import java.lang.*;

	/**
	* A generic superclass for streams which read and parse text
	* consisting of runs of characters interspersed with occasional
	* ``specials'' (formatting characters).
	*
	* <p> Most of the functionality
	* of this class would be redundant except that the
	* <code>ByteToChar</code> converters
	* are suddenly private API. Presumably this class will disappear
	* when the API is made public again. (sigh) That will also let us handle
	* multibyte character sets...
	*
	* <P> A subclass should override at least <code>write(char)</code>
	* and <code>writeSpecial(int)</code>. For efficiency's sake it's a
	* good idea to override <code>write(String)</code> as well. The subclass'
	* initializer may also install appropriate translation and specials tables.
	*
	* @see OutputStream
	*/
	abstract class AbstractFilter extends OutputStream
	{
	/** A table mapping bytes to characters */
	protected char translationTable[];
	/** A table indicating which byte values should be interpreted as
	* characters and which should be treated as formatting codes */
	protected boolean specialsTable[];

	/** A translation table which does ISO Latin-1 (trivial) */
	static final char latin1TranslationTable[];
	/** A specials table which indicates that no characters are special */
	static final boolean noSpecialsTable[];
	/** A specials table which indicates that all characters are special */
	static final boolean allSpecialsTable[];

	static {
	int i;

	noSpecialsTable = new boolean[256];
	for (i = 0; i < 256; i++)
	noSpecialsTable[i] = false;

	allSpecialsTable = new boolean[256];
	for (i = 0; i < 256; i++)
	allSpecialsTable[i] = true;

	latin1TranslationTable = new char[256];
	for (i = 0; i < 256; i++)
	latin1TranslationTable[i] = (char)i;
	}

	/**
	* A convenience method that reads text from a FileInputStream
	* and writes it to the receiver.
	* The format in which the file
	* is read is determined by the concrete subclass of
	* AbstractFilter to which this method is sent.
	* <p>This method does not close the receiver after reaching EOF on
	* the input stream.
	* The user must call <code>close()</code> to ensure that all
	* data are processed.
	*
	* @param in An InputStream providing text.
	*/
	public void readFromStream(InputStream in)
	throws IOException
	{
	byte buf[];
	int count;

	buf = new byte[16384];

	while(true) {
	count = in.read(buf);
	if (count < 0)
	break;

	this.write(buf, 0, count);
	}
	}

	public void readFromReader(Reader in)
	throws IOException
	{
	char buf[];
	int count;

	buf = new char[2048];

	while(true) {
	count = in.read(buf);
	if (count < 0)
	break;
	for (int i = 0; i < count; i++) {
	this.write(buf[i]);
	}
	}
	}

	public AbstractFilter()
	{
	translationTable = latin1TranslationTable;
	specialsTable = noSpecialsTable;
	}

	/**
	* Implements the abstract method of OutputStream, of which this class
	* is a subclass.
	*/
	public void write(int b)
	throws IOException
	{
	if (b < 0)
	b += 256;
	if (specialsTable[b])
	writeSpecial(b);
	else {
	char ch = translationTable[b];
	if (ch != (char)0)
	write(ch);
	}
	}

	/**
	* Implements the buffer-at-a-time write method for greater
	* efficiency.
	*
	* <p> <strong>PENDING:</strong> Does <code>write(byte[])</code>
	* call <code>write(byte[], int, int)</code> or is it the other way
	* around?
	*/
	public void write(byte[] buf, int off, int len)
	throws IOException
	{
	StringBuilder accumulator = null;
	while (len > 0) {
	short b = (short)buf[off];

	// stupid signed bytes
	if (b < 0)
	b += 256;

	if (specialsTable[b]) {
	if (accumulator != null) {
	write(accumulator.toString());
	accumulator = null;
	}
	writeSpecial(b);
	} else {
	char ch = translationTable[b];
	if (ch != (char)0) {
	if (accumulator == null)
	accumulator = new StringBuilder();
	accumulator.append(ch);
	}
	}

	len --;
	off ++;
	}

	if (accumulator != null)
	write(accumulator.toString());
	}

	/**
	* Hopefully, all subclasses will override this method to accept strings
	* of text, but if they don't, AbstractFilter's implementation
	* will spoon-feed them via <code>write(char)</code>.
	*
	* @param s The string of non-special characters written to the
	* OutputStream.
	*/
	public void write(String s)
	throws IOException
	{
	int index, length;

	length = s.length();
	for(index = 0; index < length; index ++) {
	write(s.charAt(index));
	}
	}

	/**
	* Subclasses must provide an implementation of this method which
	* accepts a single (non-special) character.
	*
	* @param ch The character written to the OutputStream.
	*/
	protected abstract void write(char ch) throws IOException;

	/**
	* Subclasses must provide an implementation of this method which
	* accepts a single special byte. No translation is performed
	* on specials.
	*
	* @param b The byte written to the OutputStream.
	*/
	protected abstract void writeSpecial(int b) throws IOException;
	}