Write a portion of an array of characters.

@param  bbuf  Array of characters
@param  off   Offset from which to start writing characters
@param  len   Number of characters to write
@throws IOException
343744
@Override
    public void write(byte bbuf[], int off, int len) throws IOException {
    	for(OutputStream os : oss) {
    		os.write(bbuf,off,len);
    	}
    }
1339289
public void write(byte b[], int off, int len)
        throws IOException
    {     
        len=prepareOutput(len);
        if (!_nulled)
            _out.write(b,off,len);
        if (_bytes==_contentLength)
            flush();
    }
11856
@Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    if(len <= 0) {
      return;
    }
    // if we havn't last seen a newline, and don't get a CR, insert a newline.
    if(charsSinceNewline > 0) {
      if(cbuf[off] != CARRIAGE_RETURN) {
        super.write(NEWLINEC, 0, NEWLINEC.length);
        charsSinceNewline = 0;
      }
      else {
        // length of this line:
        int nonnl = countNonNewline(cbuf, off + 1, len - 1);
        // clear the existing chars.
        if(nonnl < charsSinceNewline) {
          super.write(CARRIAGE_RETURN);
          while(charsSinceNewline > 0) {
            final int n = Math.min(charsSinceNewline, WHITESPACE.length());
            super.write(WHITESPACE, 0, n);
            charsSinceNewline -= n;
          }
        }
        else {
          charsSinceNewline = 0;
        }
      }
    }
    charsSinceNewline = tailingNonNewline(cbuf, off, len);
    super.write(cbuf, off, len);
    flush();
  }
673389
public void write(byte[] b, int off, int len) throws IOException
  {
                if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {  //306998.15
                        logger.logp(Level.FINE, CLASS_NAME,"write", "Writing");
        }

    if (_observer != null)
      _observer.alertFirstWrite();
    _conn.write(b, off, len);
  }
84364
@Override
  public void write(String s, int off, int len)
    throws IOException
  {
    char []buffer = _tempCharBuffer;
    int bufferLength = buffer.length;
    
    while (len > 0) {
      int sublen = Math.min(len, bufferLength);
      
      s.getChars(off, off + sublen, buffer, 0);
      
      write(buffer, 0, sublen);
      
      off += sublen;
      len -= sublen;
    }
  }
1238118
@Override
    public void write(char[] cbuf, int off, int len) throws IOException {
        try {
            String indexedHash =
                    RmiJournalReceiverHelper.figureIndexedHash(repositoryHash,
                                                               itemIndex);
            receiver.writeText(indexedHash, new String(cbuf, off, len));
            itemIndex++;
        } catch (JournalException e) {
            throw new IOException(e);
        }
    }
1243915
public int write(OutputStreamWithBuffer os, char []cbuf, int off, int len)
    throws IOException
  {
    for (int i = 0; i < len; i++) {
      char ch = cbuf[off + i];

      if (ch < 0x80)
        os.write(ch);
      else {
        os.write('\\');
        os.write('u');

        int b = (ch >> 12) & 0xf;
        os.write(b < 10 ? b + '0' : b + 'a' - 10);
        b = (ch >> 8) & 0xf;
        os.write(b < 10 ? b + '0' : b + 'a' - 10);
        b = (ch >> 4) & 0xf;
        os.write(b < 10 ? b + '0' : b + 'a' - 10);
        b = ch & 0xf;
        os.write(b < 10 ? b + '0' : b + 'a' - 10);
      }
    }
    
    return len;
  }
696554
@Override
	public void write(char[] cbuf, int off, int len) throws IOException {
		for (int count = 0; count < len; ++off, ++count) {
			char c = cbuf[off];

			switch (state) {
			case TEXT:
				if (c == '$') {
					state = State.VARIABLE_MARK;
				} else {
					targetWriter.write(c);
				}
				break;

			case VARIABLE_MARK:
				if (c == '{') {
					state = State.VARIABLE;
					variableBuilder.setLength(0);
				} else {
					targetWriter.write('$');
					targetWriter.write(c);
					state = State.TEXT;
				}
				break;

			case VARIABLE:
				if (c == '}') {
					String variable = variables.get(variableBuilder.toString());
					if (variable == null) {
						// if variable not found it should be an internal variable used by processing file
						// for example ${BUILD} from ant files; copy as it is
						targetWriter.write("${");
						targetWriter.write(variableBuilder.toString());
						targetWriter.write('}');
					} else {
						targetWriter.write(variable);
					}
					state = State.TEXT;
				} else {
					variableBuilder.append(c);
				}
				break;

			default:
				throw new IllegalStateException();
			}
		}
	}
1087278
protected void set(final byte[] buf, final int off, final int len) {
        _skipped = new int[0];
        _skippedWriteIndex = 0;
        _bufferedString.set(buf, off, len);
    }
277336
public void write(byte[] b, int off, int len)
        throws IOException
    {
        if (_encoding==null)
            _writer.write(new String(b,off,len));
        else
            _writer.write(new String(b,off,len,_encoding));
    }
136870
public ChainWriter write(char buf[], int off, int len) {
		out.write(buf, off, len);
		return this;
	}
34507
@Override
  public void write(byte[] b, int off, int len) throws IOException {
    inner.write(b, off, len);
  }
244022
public void write(byte[] b,int offset, int length)
        throws IOException
    {
        ensureSpareCapacity(length);
        System.arraycopy(b,offset,_buf,_pos,length);
        _pos+=length;
    }
505928
@Override
  public void write(byte[] b, int off, int len) {
    write(new String(b, off, len));
  }
1302519
@Override
    public synchronized void write(byte[] b, int off, int len) throws IOException {
        super.write(b, off, len);
        this.branch.write(b, off, len);
    }
771682
@Override
    public int read( char[] cbuf, int off, int len ) throws IOException {
        assert len >= 0;
        assert off >= 0;

        int amountRead = 0;
        final int endIndex = off + len;
        for ( int index = off; index < endIndex; index++ ) {
            int readChar = read();
            if ( readChar == -1 ) {
                break;
            }

            cbuf[ index ] = ( char ) readChar;
            amountRead++;
        }

        return amountRead == 0 ? -1 : amountRead;
    }
1315383
public void write (byte[] buf, int off, int len)
            throws IOException
     {
            out.write (buf, off, len);
     }