Clover coverage report - groovy - 1.0-beta-6
Coverage timestamp: Thu Jul 15 2004 13:18:22 BST
file stats: LOC: 121   Methods: 8
NCLOC: 34   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 Source file Conditionals Statements Methods TOTAL
StringBufferWriter.java 0% 0% 0% 0%
coverage
 1   
 /*
 2   
  * $Id: StringBufferWriter.java,v 1.1 2004/01/27 20:55:44 jstrachan Exp $
 3   
  * 
 4   
  * Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
 5   
  * 
 6   
  * Redistribution and use of this software and associated documentation
 7   
  * ("Software"), with or without modification, are permitted provided that the
 8   
  * following conditions are met: 1. Redistributions of source code must retain
 9   
  * copyright statements and notices. Redistributions must also contain a copy
 10   
  * of this document. 2. Redistributions in binary form must reproduce the above
 11   
  * copyright notice, this list of conditions and the following disclaimer in
 12   
  * the documentation and/or other materials provided with the distribution. 3.
 13   
  * The name "groovy" must not be used to endorse or promote products derived
 14   
  * from this Software without prior written permission of The Codehaus. For
 15   
  * written permission, please contact info@codehaus.org. 4. Products derived
 16   
  * from this Software may not be called "groovy" nor may "groovy" appear in
 17   
  * their names without prior written permission of The Codehaus. "groovy" is a
 18   
  * registered trademark of The Codehaus. 5. Due credit should be given to The
 19   
  * Codehaus - http://groovy.codehaus.org/
 20   
  * 
 21   
  * THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS ``AS IS'' AND ANY
 22   
  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 23   
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 24   
  * DISCLAIMED. IN NO EVENT SHALL THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR
 25   
  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 26   
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 27   
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 28   
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 29   
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 30   
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 31   
  * DAMAGE.
 32   
  *  
 33   
  */
 34   
 package org.codehaus.groovy.runtime;
 35   
 
 36   
 import java.io.IOException;
 37   
 import java.io.Writer;
 38   
 
 39   
 /**
 40   
  * This class codes around a silly limiation of StringWriter which doesn't allow a StringBuffer
 41   
  * to be passed in as a constructor for some bizzare reason.
 42   
  * So we replicate the behaviour of StringWriter here but allow a StringBuffer to be passed in.
 43   
  * 
 44   
  * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
 45   
  * @version $Revision: 1.1 $
 46   
  */
 47   
 public class StringBufferWriter extends Writer {
 48   
 
 49   
     private StringBuffer buffer;
 50   
 
 51   
     /**
 52   
      * Create a new string writer which will append the text to the given StringBuffer
 53   
      */
 54  0
     public StringBufferWriter(StringBuffer buffer) {
 55  0
         this.buffer = buffer;
 56   
     }
 57   
 
 58   
     /**
 59   
      * Write a single character.
 60   
      */
 61  0
     public void write(int c) {
 62  0
         buffer.append((char) c);
 63   
     }
 64   
 
 65   
     /**
 66   
      * Write a portion of an array of characters.
 67   
      *
 68   
      * @param text Array of characters
 69   
      * @param offset Offset from which to start writing characters
 70   
      * @param length Number of characters to write
 71   
      */
 72  0
     public void write(char text[], int offset, int length) {
 73  0
         if ((offset < 0) || (offset > text.length) || (length < 0) || ((offset + length) > text.length) || ((offset + length) < 0)) {
 74  0
             throw new IndexOutOfBoundsException();
 75   
         }
 76  0
         else if (length == 0) {
 77  0
             return;
 78   
         }
 79  0
         buffer.append(text, offset, length);
 80   
     }
 81   
 
 82   
     /**
 83   
      * Write a string.
 84   
      */
 85  0
     public void write(String text) {
 86  0
         buffer.append(text);
 87   
     }
 88   
 
 89   
     /**
 90   
      * Write a portion of a string.
 91   
      *
 92   
      * @param text the text to be written
 93   
      * @param offset offset from which to start writing characters
 94   
      * @param length Number of characters to write
 95   
      */
 96  0
     public void write(String text, int offset, int length) {
 97  0
         buffer.append(text.substring(offset, offset + length));
 98   
     }
 99   
 
 100   
     /**
 101   
      * Return the buffer's current value as a string.
 102   
      */
 103  0
     public String toString() {
 104  0
         return buffer.toString();
 105   
     }
 106   
 
 107   
     /**
 108   
      * Flush the stream.
 109   
      */
 110  0
     public void flush() {
 111   
     }
 112   
 
 113   
     /**
 114   
      * Closing a <tt>StringWriter</tt> has no effect. The methods in this
 115   
      * class can be called after the stream has been closed without generating
 116   
      * an <tt>IOException</tt>.
 117   
      */
 118  0
     public void close() throws IOException {
 119   
     }
 120   
 }
 121