001    /**
002     *  Licensed to the Apache Software Foundation (ASF) under one or more
003     *  contributor license agreements.  See the NOTICE file distributed with
004     *  this work for additional information regarding copyright ownership.
005     *  The ASF licenses this file to You under the Apache License, Version 2.0
006     *  (the "License"); you may not use this file except in compliance with
007     *  the License.  You may obtain a copy of the License at
008     *
009     *     http://www.apache.org/licenses/LICENSE-2.0
010     *
011     *  Unless required by applicable law or agreed to in writing, software
012     *  distributed under the License is distributed on an "AS IS" BASIS,
013     *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     *  See the License for the specific language governing permissions and
015     *  limitations under the License.
016     */
017    
018    package org.apache.geronimo.util.encoders;
019    
020    import java.io.ByteArrayOutputStream;
021    import java.io.IOException;
022    import java.io.OutputStream;
023    
024    public class Base64
025    {
026        private static final Encoder encoder = new Base64Encoder();
027    
028        /**
029         * encode the input data producing a base 64 encoded byte array.
030         *
031         * @return a byte array containing the base 64 encoded data.
032         */
033        public static byte[] encode(
034            byte[]    data)
035        {
036            ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
037    
038            try
039            {
040                encoder.encode(data, 0, data.length, bOut);
041            }
042            catch (IOException e)
043            {
044                throw new RuntimeException("exception encoding base64 string: " + e.getMessage(), e);
045            }
046    
047            return bOut.toByteArray();
048        }
049    
050        /**
051         * Encode the byte data to base 64 writing it to the given output stream.
052         *
053         * @return the number of bytes produced.
054         */
055        public static int encode(
056            byte[]                data,
057            OutputStream    out)
058            throws IOException
059        {
060            return encoder.encode(data, 0, data.length, out);
061        }
062    
063        /**
064         * Encode the byte data to base 64 writing it to the given output stream.
065         *
066         * @return the number of bytes produced.
067         */
068        public static int encode(
069            byte[]                data,
070            int                    off,
071            int                    length,
072            OutputStream    out)
073            throws IOException
074        {
075            return encoder.encode(data, off, length, out);
076        }
077    
078        /**
079         * decode the base 64 encoded input data. It is assumed the input data is valid.
080         *
081         * @return a byte array representing the decoded data.
082         */
083        public static byte[] decode(
084            byte[]    data)
085        {
086            ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
087    
088            try
089            {
090                encoder.decode(data, 0, data.length, bOut);
091            }
092            catch (IOException e)
093            {
094                throw new RuntimeException("exception decoding base64 string: " + e.getMessage(), e);
095            }
096    
097            return bOut.toByteArray();
098        }
099    
100        /**
101         * decode the base 64 encoded String data - whitespace will be ignored.
102         *
103         * @return a byte array representing the decoded data.
104         */
105        public static byte[] decode(
106            String    data)
107        {
108            ByteArrayOutputStream    bOut = new ByteArrayOutputStream();
109    
110            try
111            {
112                encoder.decode(data, bOut);
113            }
114            catch (IOException e)
115            {
116                throw new RuntimeException("exception decoding base64 string: " + e.getMessage(), e);
117            }
118    
119            return bOut.toByteArray();
120        }
121    
122        /**
123         * decode the base 64 encoded String data writing it to the given output stream,
124         * whitespace characters will be ignored.
125         *
126         * @return the number of bytes produced.
127         */
128        public static int decode(
129            String                data,
130            OutputStream    out)
131            throws IOException
132        {
133            return encoder.decode(data, out);
134        }
135    }