lib/jetty/org/eclipse/jetty/util/ByteArrayISO8859Writer.java

   1 //
   2 //  ========================================================================
   3 //  Copyright (c) 1995-2016 Mort Bay Consulting Pty. Ltd.
   4 //  ------------------------------------------------------------------------
   5 //  All rights reserved. This program and the accompanying materials
   6 //  are made available under the terms of the Eclipse Public License v1.0
   7 //  and Apache License v2.0 which accompanies this distribution.
   8 //
   9 //      The Eclipse Public License is available at
  10 //      http://www.eclipse.org/legal/epl-v10.html
  11 //
  12 //      The Apache License v2.0 is available at
  13 //      http://www.opensource.org/licenses/apache2.0.php
  14 //
  15 //  You may elect to redistribute this code under either of these licenses.
  16 //  ========================================================================
  17 //
  18
  19 package org.eclipse.jetty.util;
  20 import java.io.IOException;
  21 import java.io.OutputStream;
  22 import java.io.OutputStreamWriter;
  23 import java.io.Writer;
  24 import java.nio.charset.StandardCharsets;
  25 import java.util.Arrays;
  26
  27
  28 /* ------------------------------------------------------------ */
  29 /** Byte Array ISO 8859 writer.
  30  * This class combines the features of a OutputStreamWriter for
  31  * ISO8859 encoding with that of a ByteArrayOutputStream.  It avoids
  32  * many inefficiencies associated with these standard library classes.
  33  * It has been optimized for standard ASCII characters.
  34  *
  35  *
  36  */
  37 public class ByteArrayISO8859Writer extends Writer
  38 {
  39     private byte[] _buf;
  40     private int _size;
  41     private ByteArrayOutputStream2 _bout=null;
  42     private OutputStreamWriter _writer=null;
  43     private boolean _fixed=false;
  44
  45     /* ------------------------------------------------------------ */
  46     /** Constructor.
  47      */
  48     public ByteArrayISO8859Writer()
  49     {
  50         _buf=new byte[2048];
  51     }
  52
  53     /* ------------------------------------------------------------ */
  54     /** Constructor.
  55      * @param capacity Buffer capacity
  56      */
  57     public ByteArrayISO8859Writer(int capacity)
  58     {
  59         _buf=new byte[capacity];
  60     }
  61
  62     /* ------------------------------------------------------------ */
  63     public ByteArrayISO8859Writer(byte[] buf)
  64     {
  65         _buf=buf;
  66         _fixed=true;
  67     }
  68
  69     /* ------------------------------------------------------------ */
  70     public Object getLock()
  71     {
  72         return lock;
  73     }
  74
  75     /* ------------------------------------------------------------ */
  76     public int size()
  77     {
  78         return _size;
  79     }
  80
  81     /* ------------------------------------------------------------ */
  82     public int capacity()
  83     {
  84         return _buf.length;
  85     }
  86
  87     /* ------------------------------------------------------------ */
  88     public int spareCapacity()
  89     {
  90         return _buf.length-_size;
  91     }
  92
  93     /* ------------------------------------------------------------ */
  94     public void setLength(int l)
  95     {
  96         _size=l;
  97     }
  98
  99     /* ------------------------------------------------------------ */
 100     public byte[] getBuf()
 101     {
 102         return _buf;
 103     }
 104
 105     /* ------------------------------------------------------------ */
 106     public void writeTo(OutputStream out)
 107         throws IOException
 108     {
 109         out.write(_buf,0,_size);
 110     }
 111
 112     /* ------------------------------------------------------------ */
 113     public void write(char c)
 114         throws IOException
 115     {
 116         ensureSpareCapacity(1);
 117         if (c>=0&&c<=0x7f)
 118             _buf[_size++]=(byte)c;
 119         else
 120         {
 121             char[] ca ={c};
 122             writeEncoded(ca,0,1);
 123         }
 124     }
 125
 126     /* ------------------------------------------------------------ */
 127     @Override
 128     public void write(char[] ca)
 129         throws IOException
 130     {
 131         ensureSpareCapacity(ca.length);
 132         for (int i=0;i<ca.length;i++)
 133         {
 134             char c=ca[i];
 135             if (c>=0&&c<=0x7f)
 136                 _buf[_size++]=(byte)c;
 137             else
 138             {
 139                 writeEncoded(ca,i,ca.length-i);
 140                 break;
 141             }
 142         }
 143     }
 144
 145     /* ------------------------------------------------------------ */
 146     @Override
 147     public void write(char[] ca,int offset, int length)
 148         throws IOException
 149     {
 150         ensureSpareCapacity(length);
 151         for (int i=0;i<length;i++)
 152         {
 153             char c=ca[offset+i];
 154             if (c>=0&&c<=0x7f)
 155                 _buf[_size++]=(byte)c;
 156             else
 157             {
 158                 writeEncoded(ca,offset+i,length-i);
 159                 break;
 160             }
 161         }
 162     }
 163
 164     /* ------------------------------------------------------------ */
 165     @Override
 166     public void write(String s)
 167         throws IOException
 168     {
 169         if (s==null)
 170         {
 171             write("null",0,4);
 172             return;
 173         }
 174
 175         int length=s.length();
 176         ensureSpareCapacity(length);
 177         for (int i=0;i<length;i++)
 178         {
 179             char c=s.charAt(i);
 180             if (c>=0x0&&c<=0x7f)
 181                 _buf[_size++]=(byte)c;
 182             else
 183             {
 184                 writeEncoded(s.toCharArray(),i,length-i);
 185                 break;
 186             }
 187         }
 188     }
 189
 190     /* ------------------------------------------------------------ */
 191     @Override
 192     public void write(String s,int offset, int length)
 193         throws IOException
 194     {
 195         ensureSpareCapacity(length);
 196         for (int i=0;i<length;i++)
 197         {
 198             char c=s.charAt(offset+i);
 199             if (c>=0&&c<=0x7f)
 200                 _buf[_size++]=(byte)c;
 201             else
 202             {
 203                 writeEncoded(s.toCharArray(),offset+i,length-i);
 204                 break;
 205             }
 206         }
 207     }
 208
 209     /* ------------------------------------------------------------ */
 210     private void writeEncoded(char[] ca,int offset, int length)
 211         throws IOException
 212     {
 213         if (_bout==null)
 214         {
 215             _bout = new ByteArrayOutputStream2(2*length);
 216             _writer = new OutputStreamWriter(_bout,StandardCharsets.ISO_8859_1);
 217         }
 218         else
 219             _bout.reset();
 220         _writer.write(ca,offset,length);
 221         _writer.flush();
 222         ensureSpareCapacity(_bout.getCount());
 223         System.arraycopy(_bout.getBuf(),0,_buf,_size,_bout.getCount());
 224         _size+=_bout.getCount();
 225     }
 226
 227     /* ------------------------------------------------------------ */
 228     @Override
 229     public void flush()
 230     {}
 231
 232     /* ------------------------------------------------------------ */
 233     public void resetWriter()
 234     {
 235         _size=0;
 236     }
 237
 238     /* ------------------------------------------------------------ */
 239     @Override
 240     public void close()
 241     {}
 242
 243     /* ------------------------------------------------------------ */
 244     public void destroy()
 245     {
 246         _buf=null;
 247     }
 248
 249     /* ------------------------------------------------------------ */
 250     public void ensureSpareCapacity(int n)
 251         throws IOException
 252     {
 253         if (_size+n>_buf.length)
 254         {
 255             if (_fixed)
 256                 throw new IOException("Buffer overflow: "+_buf.length);
 257             _buf=Arrays.copyOf(_buf,(_buf.length+n)*4/3);
 258         }
 259     }
 260
 261     /* ------------------------------------------------------------ */
 262     public byte[] getByteArray()
 263     {
 264         return Arrays.copyOf(_buf,_size);
 265     }
 266
 267 }
 268
 269