Clover coverage report -
Coverage timestamp: Sun Nov 1 2009 23:08:24 UTC
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 533   Methods: 69
NCLOC: 386   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
ByteBuffer.java 0% 0% 0% 0%
coverage
 1    /*
 2    * Licensed to the Apache Software Foundation (ASF) under one or more
 3    * contributor license agreements. See the NOTICE file distributed with
 4    * this work for additional information regarding copyright ownership.
 5    * The ASF licenses this file to You under the Apache License, Version 2.0
 6    * (the "License"); you may not use this file except in compliance with
 7    * the License. You may obtain a copy of the License at
 8    *
 9    * http://www.apache.org/licenses/LICENSE-2.0
 10    *
 11    * Unless required by applicable law or agreed to in writing, software
 12    * distributed under the License is distributed on an "AS IS" BASIS,
 13    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14    * See the License for the specific language governing permissions and
 15    * limitations under the License.
 16    *
 17    * $Id: ByteBuffer.java 541508 2007-05-25 01:54:12Z vgritsenko $
 18    */
 19   
 20    package org.apache.xindice.util;
 21   
 22    import java.io.ByteArrayInputStream;
 23    import java.io.IOException;
 24    import java.io.InputStream;
 25    import java.io.ObjectInputStream;
 26    import java.io.ObjectOutputStream;
 27    import java.io.OutputStream;
 28    import java.io.Serializable;
 29    import java.io.UnsupportedEncodingException;
 30   
 31    import org.apache.commons.logging.Log;
 32    import org.apache.commons.logging.LogFactory;
 33   
 34    /**
 35    * ByteBuffer manages volatile arrays of bytes. It is implemented with
 36    * nearly the same method prototypes as StringBuffer except for the
 37    * setByteAt and byteAt methods which replace
 38    * StringBuffer's setCharAt and charAt methods.
 39    * ByteBuffer also extends the OutputStream abstract class and
 40    * functions like the ByteArrayOutputStream class.
 41    * getInputStream returns an InputStream instance for
 42    * streaming in the content of the ByteBuffer. Because none of the
 43    * methods in ByteBuffer are synchronized, it is the user's job to
 44    * properly synchronize calls to any of the methods of this class.
 45    *
 46    * @version $Revision: 541508 $, $Date: 2007-05-24 18:54:12 -0700 (Thu, 24 May 2007) $
 47    */
 48    public final class ByteBuffer extends OutputStream implements Serializable {
 49   
 50    private static final Log log = LogFactory.getLog(ByteBuffer.class);
 51   
 52    static final long serialVersionUID = -3900903004630456844L;
 53   
 54    private transient int length = 0;
 55   
 56    private byte[] buffer = null;
 57    private boolean locked = false;
 58   
 59  0 public ByteBuffer(int size) {
 60  0 buffer = new byte[size];
 61    }
 62   
 63  0 public ByteBuffer(String value) {
 64   
 65  0 try {
 66   
 67  0 buffer = value.getBytes("utf-8");
 68  0 length = buffer.length;
 69    } catch (UnsupportedEncodingException e) {
 70   
 71  0 throw new IllegalStateException("Java doesn't seem to support UTF-8");
 72    }
 73    }
 74   
 75  0 public ByteBuffer(StringBuffer value) {
 76  0 this(value.toString());
 77    }
 78   
 79  0 public ByteBuffer(byte[] value, boolean copy) {
 80  0 length = value.length;
 81  0 if (copy) {
 82  0 buffer = new byte[length];
 83  0 System.arraycopy(value, 0, buffer, 0, length);
 84    } else {
 85  0 buffer = value;
 86    }
 87    }
 88   
 89  0 public ByteBuffer(byte[] value) {
 90  0 length = value.length;
 91  0 buffer = new byte[length];
 92  0 System.arraycopy(value, 0, buffer, 0, length);
 93    }
 94   
 95  0 public ByteBuffer() {
 96  0 this(64);
 97    }
 98   
 99  0 public int capacity() {
 100  0 return buffer.length;
 101    }
 102   
 103  0 public void ensureCapacity(int size) {
 104  0 if (locked) {
 105  0 return;
 106    }
 107  0 checkCapacity(size);
 108    }
 109   
 110  0 private void checkCapacity(int size) {
 111  0 if (size > buffer.length) {
 112  0 int newsize = (buffer.length + 1) * 2;
 113  0 if (size > newsize) {
 114  0 newsize = size;
 115    }
 116  0 byte[] old = buffer;
 117  0 buffer = new byte[newsize];
 118  0 System.arraycopy(old, 0, buffer, 0, old.length);
 119    }
 120    }
 121   
 122  0 public void pack() {
 123  0 if (locked) {
 124  0 return;
 125    }
 126  0 if (buffer.length > length) {
 127  0 byte[] value = new byte[length];
 128  0 System.arraycopy(buffer, 0, value, 0, length);
 129  0 buffer = value;
 130    }
 131    }
 132   
 133    /* StringBuffer style methods */
 134   
 135  0 public void append(byte[] value) {
 136  0 if (locked) {
 137  0 return;
 138    }
 139  0 checkCapacity(length + value.length);
 140  0 System.arraycopy(value, 0, buffer, length, value.length);
 141  0 length += value.length;
 142    }
 143   
 144  0 public void append(char[] value) {
 145   
 146  0 append(new String(value));
 147    }
 148   
 149  0 public void append(String value) {
 150   
 151  0 try {
 152   
 153  0 append(value.getBytes("utf-8"));
 154    } catch (UnsupportedEncodingException e) {
 155   
 156  0 throw new IllegalStateException("Java doesn't seem to know UTF-8...");
 157    }
 158    }
 159   
 160  0 public void append(StringBuffer value) {
 161  0 append(value.toString());
 162    }
 163   
 164  0 public void append(ByteBuffer value) {
 165  0 try {
 166  0 value.writeTo(this);
 167    } catch (Exception e) {
 168  0 if (log.isWarnEnabled()) {
 169  0 log.warn("ignored exception", e);
 170    }
 171    }
 172    }
 173   
 174  0 public void append(boolean value) {
 175  0 append(String.valueOf(value));
 176    }
 177   
 178  0 public void append(char value) {
 179  0 if (locked) {
 180  0 return;
 181    }
 182  0 append(new char[]{value});
 183    }
 184   
 185  0 public void append(byte value) {
 186  0 if (locked) {
 187  0 return;
 188    }
 189  0 checkCapacity(length + 1);
 190  0 buffer[length++] = value;
 191    }
 192   
 193  0 public void append(double value) {
 194  0 append(String.valueOf(value));
 195    }
 196   
 197  0 public void append(float value) {
 198  0 append(String.valueOf(value));
 199    }
 200   
 201  0 public void append(int value) {
 202  0 append(String.valueOf(value));
 203    }
 204   
 205  0 public void append(long value) {
 206  0 append(String.valueOf(value));
 207    }
 208   
 209  0 public void append(Object value) {
 210  0 append(String.valueOf(value));
 211    }
 212   
 213  0 public void insert(byte[] value, int pos) {
 214  0 if (locked) {
 215  0 return;
 216    }
 217  0 if (pos < 0 || pos >= length) {
 218  0 throw new IndexOutOfBoundsException();
 219    }
 220  0 checkCapacity(length + value.length);
 221  0 byte[] temp = new byte[length - pos];
 222  0 System.arraycopy(buffer, pos, temp, 0, temp.length);
 223  0 System.arraycopy(temp, 0, buffer, pos + value.length, temp.length);
 224  0 System.arraycopy(value, 0, buffer, pos, value.length);
 225  0 length += value.length;
 226    }
 227   
 228  0 public void insert(char[] value, int pos) {
 229  0 if (locked) {
 230  0 return;
 231    }
 232   
 233  0 insert(new String(value), pos);
 234    }
 235   
 236  0 public void insert(String value, int pos) {
 237  0 try {
 238   
 239  0 insert(value.getBytes("utf-8"), pos);
 240    } catch (UnsupportedEncodingException e) {
 241   
 242  0 throw new IllegalStateException("Java doesn't seem to support UTF-8");
 243    }
 244    }
 245   
 246  0 public void insert(StringBuffer value, int pos) {
 247   
 248  0 insert(value.toString(), pos);
 249    }
 250   
 251  0 public void insert(ByteBuffer value, int pos) {
 252  0 insert(value.toByteArray(), pos);
 253    }
 254   
 255  0 public void insert(boolean value, int pos) {
 256  0 insert(String.valueOf(value), pos);
 257    }
 258   
 259  0 public void insert(char value, int pos) {
 260   
 261  0 insert(new char[]{value}, pos);
 262    }
 263   
 264  0 public void insert(byte value, int pos) {
 265  0 if (locked) {
 266  0 return;
 267    }
 268  0 if (pos < 0 || pos >= length) {
 269  0 throw new IndexOutOfBoundsException();
 270    }
 271  0 checkCapacity(length + 1);
 272  0 byte[] temp = new byte[length - pos];
 273  0 System.arraycopy(buffer, pos, temp, 0, temp.length);
 274  0 System.arraycopy(temp, 0, buffer, pos + 1, temp.length);
 275  0 buffer[pos] = value;
 276  0 length++;
 277    }
 278   
 279  0 public void insert(double value, int pos) {
 280  0 insert(String.valueOf(value), pos);
 281    }
 282   
 283  0 public void insert(float value, int pos) {
 284  0 insert(String.valueOf(value), pos);
 285    }
 286   
 287  0 public void insert(int value, int pos) {
 288  0 insert(String.valueOf(value), pos);
 289    }
 290   
 291  0 public void insert(long value, int pos) {
 292  0 insert(String.valueOf(value), pos);
 293    }
 294   
 295  0 public void insert(Object value, int pos) {
 296  0 insert(String.valueOf(value), pos);
 297    }
 298   
 299  0 public void delete(int pos, int width) {
 300  0 if (locked) {
 301  0 return;
 302    }
 303  0 if (pos + width > length) {
 304  0 width = (length - pos);
 305    }
 306  0 byte[] temp = new byte[length - (pos + width)];
 307  0 System.arraycopy(buffer, pos + width, temp, 0, temp.length);
 308  0 System.arraycopy(temp, 0, buffer, pos, temp.length);
 309  0 length -= width;
 310    }
 311   
 312  0 public void replace(byte[] value, int pos, int width) {
 313  0 delete(pos, width);
 314  0 insert(value, pos);
 315    }
 316   
 317  0 public void replace(String value, int pos, int width) {
 318  0 try {
 319   
 320  0 replace(value.getBytes("utf-8"), pos, width);
 321    } catch (UnsupportedEncodingException e) {
 322   
 323  0 throw new IllegalStateException("Java doesn't seem to know UTF-8");
 324    }
 325    }
 326   
 327  0 public void replace(StringBuffer value, int pos, int width) {
 328   
 329  0 replace(value.toString(), pos, width);
 330    }
 331   
 332  0 public void replace(ByteBuffer value, int pos, int width) {
 333   
 334  0 replace(value.toByteArray(), pos, width);
 335    }
 336   
 337  0 public void replace(boolean value, int pos, int width) {
 338   
 339  0 replace(String.valueOf(value), pos, width);
 340    }
 341   
 342  0 public void replace(char value, int pos, int width) {
 343   
 344  0 replace(String.valueOf(value), pos, width);
 345    }
 346   
 347  0 public void replace(double value, int pos, int width) {
 348   
 349  0 replace(String.valueOf(value), pos, width);
 350    }
 351   
 352  0 public void replace(float value, int pos, int width) {
 353   
 354  0 replace(String.valueOf(value), pos, width);
 355    }
 356   
 357  0 public void replace(int value, int pos, int width) {
 358   
 359  0 replace(String.valueOf(value), pos, width);
 360    }
 361   
 362  0 public void replace(long value, int pos, int width) {
 363   
 364  0 replace(String.valueOf(value), pos, width);
 365    }
 366   
 367  0 public void replace(Object value, int pos, int width) {
 368   
 369  0 replace(String.valueOf(value), pos, width);
 370    }
 371   
 372  0 public byte[] toByteArray() {
 373   
 374  0 byte[] value = new byte[length];
 375  0 System.arraycopy(buffer, 0, value, 0, length);
 376  0 return value;
 377    }
 378   
 379  0 public String toString() {
 380   
 381  0 try {
 382   
 383  0 return new String(buffer, "utf-8");
 384    } catch (UnsupportedEncodingException e) {
 385   
 386  0 throw new IllegalStateException("Java doesn't seem to support UTF-8");
 387    }
 388    }
 389   
 390  0 public int length() {
 391  0 return length;
 392    }
 393   
 394  0 public void setLength(int value) {
 395  0 if (locked) {
 396  0 return;
 397    }
 398  0 if (value < 0 || value > length) {
 399  0 throw new IndexOutOfBoundsException();
 400    }
 401  0 length = value;
 402    }
 403   
 404    /* ByteArrayOutputStream style methods */
 405   
 406  0 public int size() {
 407  0 return length;
 408    }
 409   
 410  0 public void reset() {
 411  0 if (locked) {
 412  0 return;
 413    }
 414  0 length = 0;
 415    }
 416   
 417  0 public byte byteAt(int index) {
 418  0 if (index < 0 || index >= length) {
 419  0 throw new IndexOutOfBoundsException();
 420    }
 421  0 return buffer[index];
 422    }
 423   
 424  0 public void setByteAt(int index, byte value) {
 425  0 if (locked) {
 426  0 return;
 427    }
 428  0 if (index < 0 || index >= length) {
 429  0 throw new IndexOutOfBoundsException();
 430    }
 431  0 buffer[index] = value;
 432    }
 433   
 434  0 public void reverse() {
 435  0 if (locked) {
 436  0 return;
 437    }
 438  0 byte b = 0;
 439  0 for (int i = 0; i < length / 2; i++) {
 440  0 b = buffer[i];
 441  0 buffer[i] = buffer[(length - 1) - i];
 442  0 buffer[(length - 1) - i] = b;
 443    }
 444    }
 445   
 446  0 public InputStream getInputStream() {
 447  0 return new ByteArrayInputStream(buffer, 0, length);
 448    }
 449   
 450  0 public void writeTo(OutputStream out) throws IOException {
 451  0 out.write(buffer, 0, length);
 452    }
 453   
 454  0 public void chunkTo(OutputStream out, int chunkSize) throws IOException {
 455  0 int pos = 0;
 456  0 int size = 0;
 457  0 while (pos < length) {
 458  0 size = length - pos > chunkSize ? chunkSize
 459    : length - pos;
 460  0 out.write(buffer, pos, size);
 461  0 pos += size;
 462  0 Thread.yield();
 463    }
 464    }
 465   
 466  0 public void chunkTo(OutputStream out) throws IOException {
 467  0 chunkTo(out, 2048);
 468    }
 469   
 470  0 public void readFrom(InputStream in) throws IOException {
 471  0 if (locked) {
 472  0 throw new IOException("ByteBuffer Is Locked");
 473    }
 474  0 int size = in.available();
 475  0 checkCapacity(length + size);
 476  0 in.read(buffer, length, size);
 477  0 length += size;
 478    }
 479   
 480  0 public void write(int b) throws IOException {
 481  0 if (locked) {
 482  0 throw new IOException("ByteBuffer Is Locked");
 483    }
 484  0 checkCapacity(length + 1);
 485  0 buffer[length++] = (byte) b;
 486    }
 487   
 488  0 public void write(byte b[]) throws IOException {
 489  0 if (locked) {
 490  0 throw new IOException("ByteBuffer Is Locked");
 491    }
 492  0 checkCapacity(length + b.length);
 493  0 System.arraycopy(b, 0, buffer, length, b.length);
 494  0 length += b.length;
 495    }
 496   
 497  0 public void write(byte b[], int off, int len) throws IOException {
 498  0 if (locked) {
 499  0 throw new IOException("ByteBuffer Is Locked");
 500    }
 501  0 checkCapacity(length + len);
 502  0 System.arraycopy(b, off, buffer, length, len);
 503  0 length += len;
 504    }
 505   
 506    /* Serialization-Related Methods */
 507   
 508  0 private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
 509    // Read the array in and set the length correctly
 510  0 in.defaultReadObject();
 511  0 length = buffer.length;
 512    }
 513   
 514  0 private void writeObject(ObjectOutputStream out) throws IOException {
 515    // Pack the array, so we're not saving crap
 516  0 pack();
 517  0 out.defaultWriteObject();
 518    }
 519   
 520    /* Buffer locking related methods */
 521   
 522  0 public void lock() {
 523  0 if (!locked) {
 524  0 pack();
 525  0 locked = true;
 526    }
 527    }
 528   
 529  0 public boolean isLocked() {
 530  0 return locked;
 531    }
 532    }
 533   
 
CloverReport generated by Clover Code Coverage v1.3.13
Sun Nov 1 2009 23:10:27 UTC.		   Open Source License registered to the Apache Xindice Project. This license of Clover is provided to support the development of Apache Xindice only.