Add simple android client.
[odfkit:webodf.git] / android / src / org / webodf / Base64OutputStream.java
1 /*
2  *
3  * $Id: BASE64OutputStream.java,v 1.1 2005/05/03 06:51:35 hamada Exp $
4  *
5  * Copyright (c) 2001 Sun Microsystems, Inc.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  *
19  * 3. The end-user documentation included with the redistribution,
20  *    if any, must include the following acknowledgment:
21  *       "This product includes software developed by the
22  *       Sun Microsystems, Inc. for Project JXTA."
23  *    Alternately, this acknowledgment may appear in the software itself,
24  *    if and wherever such third-party acknowledgments normally appear.
25  *
26  * 4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA"
27  *    must not be used to endorse or promote products derived from this
28  *    software without prior written permission. For written
29  *    permission, please contact Project JXTA at http://www.jxta.org.
30  *
31  * 5. Products derived from this software may not be called "JXTA",
32  *    nor may "JXTA" appear in their name, without prior written
33  *    permission of Sun.
34  *
35  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
36  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
37  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
38  * DISCLAIMED.  IN NO EVENT SHALL SUN MICROSYSTEMS OR
39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
41  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
42  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
43  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
44  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
45  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
46  * SUCH DAMAGE.
47  *
48  * ====================================================================
49  *
50  * This software consists of voluntary contributions made by many
51  * individuals on behalf of Project JXTA.  For more
52  * information on Project JXTA, please see
53  * .
54  *
55  * This license is based on the BSD license adopted by the Apache Foundation.
56  */
57
58 package org.webodf;
59
60 import java.io.IOException;
61 import java.io.OutputStream;
62 import java.io.Writer;
63
64 /**
65  * An OutputStream implementation which encodes the written bytes into BASE64
66  * encoded character data and writes the output to an associated text Writer.
67  * 
68  * 
69  * 
70  * This implementation is not thread safe. * * @see
71  * net.jxta.impl.util.BASE64InputStream * @see IETF RFC 2045 MIME : Format of
72  * Internet Message BodiesW
73  */
74 public class Base64OutputStream extends OutputStream {
75         /** * If true then the output stream has been closed. */
76         private boolean closed = false;
77         /** * The output writer. */
78         private Writer sendTo = null;
79         /** * Buffer for incomplete characters. */
80         private byte[] buffer = new byte[] { 0, 0, 0 };
81         /** * The number of characters currently in the buffer. */
82         private byte inBuffer = 0;
83
84         /**
85          * * Construct a BASE64 Output Stream. * * @param sendTo The text Writer to
86          * which the BASE64 output will be * written.
87          */
88         public Base64OutputStream(Writer sendTo) {
89                 this.sendTo = sendTo;
90         }
91
92         /** * {@inheritDoc} */
93         public void write(int b) throws IOException {
94                 if (closed) {
95                         throw new IOException("OutputStream closed.");
96                 }
97                 buffer[inBuffer++] = (byte) b;
98                 if (buffer.length == inBuffer) {
99                         writeBuffer();
100                 }
101         }
102
103         /**
104          * * {@inheritDoc} * *
105          * 
106          * The output writer is NOT closed.
107          */
108         public void close() throws IOException {
109                 flush();
110                 closed = true;
111                 sendTo = null;
112         }
113
114         /** * {@inheritDoc} */
115         public void flush() throws IOException {
116                 writeBuffer();
117         }
118
119         /** * Write a full or partial buffer to the output writer. */
120         private void writeBuffer() throws IOException {
121                 if (0 == inBuffer) {
122                         return;
123                 }
124                 int val = ((buffer[0] & 0x00FF) << 16) + ((buffer[1] & 0x00FF) << 8)
125                                 + (buffer[2] & 0x00FF);
126                 int c0 = (val >> 18) & 0x003F;
127                 int c1 = (val >> 12) & 0x003F;
128                 int c2 = (val >> 6) & 0x003F;
129                 int c3 = val & 0x003F;
130                 sendTo.write(encodeSixBits(c0));
131                 sendTo.write(encodeSixBits(c1));
132                 if (inBuffer > 1) {
133                         sendTo.write(encodeSixBits(c2));
134                 } else {
135                         sendTo.write('=');
136                 }
137                 if (inBuffer > 2) {
138                         sendTo.write(encodeSixBits(c3));
139                 } else {
140                         sendTo.write('=');
141                 }
142                 buffer[0] = 0;
143                 buffer[1] = 0;
144                 buffer[2] = 0;
145                 inBuffer = 0;
146         }
147
148         /** * BASE64 Encoding Table */
149         static final char encode[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
150                         'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
151                         'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
152                         'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
153                         'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8',
154                         '9', '+', '/' };
155
156         /**
157          * * Encode six bits into a character using the standard BASE64 table. * * @param
158          * b the bits to encode. b must be >=0 and <= 63 * @return the appropriate
159          * character for the input value.
160          */
161         private static char encodeSixBits(int b) {
162                 char c;
163                 if ((b < 0) || (b > 63))
164                         throw new IllegalArgumentException("bad encode value");
165                 else
166                         c = encode[b];
167                 return c;
168         }
169 }