public  void close() throws IOException 
{
        synchronized (lock) {
            if (!isOpen)
                return;
            implClose();
            isOpen = false;
        }
}

 String encodingName() 
{
        return ((cs instanceof HistoricallyNamedCharset)
            ? ((HistoricallyNamedCharset)cs).historicalName()
            : cs.name());
}

 public  void flush() throws IOException 
{
        synchronized (lock) {
            ensureOpen();
            implFlush();
        }
}

 public  void flushBuffer() throws IOException 
{
        synchronized (lock) {
            if (isOpen())
                implFlushBuffer();
            else
                throw new IOException("Stream closed");
        }
}

 public static StreamEncoder forEncoder(WritableByteChannel ch,
    CharsetEncoder enc,
    int minBufferCap) 
{
        return new StreamEncoder(ch, enc, minBufferCap);
}

 public static StreamEncoder forOutputStreamWriter(OutputStream out,
    Object lock,
    String charsetName) throws UnsupportedEncodingException 
{
        String csn = charsetName;
        if (csn == null)
            csn = Charset.defaultCharset().name();
        try {
            if (Charset.isSupported(csn))
                return new StreamEncoder(out, lock, Charset.forName(csn));
        } catch (IllegalCharsetNameException x) { }
        throw new UnsupportedEncodingException (csn);
}

 public static StreamEncoder forOutputStreamWriter(OutputStream out,
    Object lock,
    Charset cs) 
{
        return new StreamEncoder(out, lock, cs);
}

 public static StreamEncoder forOutputStreamWriter(OutputStream out,
    Object lock,
    CharsetEncoder enc) 
{
        return new StreamEncoder(out, lock, enc);
}

 public String getEncoding() 
{
        if (isOpen())
            return encodingName();
        return null;
}

  void implClose() throws IOException 
{
        flushLeftoverChar(null, true);
        try {
            for (;;) {
                CoderResult cr = encoder.flush(bb);
                if (cr.isUnderflow())
                    break;
                if (cr.isOverflow()) {
                    assert bb.position()  > 0;
                    writeBytes();
                    continue;
                }
                cr.throwException();
            }
            if (bb.position()  > 0)
                writeBytes();
            if (ch != null)
                ch.close();
            else
                out.close();
        } catch (IOException x) {
            encoder.reset();
            throw x;
        }
}

  void implFlush() throws IOException 
{
        implFlushBuffer();
        if (out != null)
        out.flush();
}

  void implFlushBuffer() throws IOException 
{
        if (bb.position()  > 0)
        writeBytes();
}

  void implWrite(char[] cbuf,
    int off,
    int len) throws IOException 
{
        CharBuffer cb = CharBuffer.wrap(cbuf, off, len);
        if (haveLeftoverChar)
        flushLeftoverChar(cb, false);
        while (cb.hasRemaining()) {
        CoderResult cr = encoder.encode(cb, bb, false);
        if (cr.isUnderflow()) {
           assert (cb.remaining() < = 1) : cb.remaining();
           if (cb.remaining() == 1) {
                haveLeftoverChar = true;
                leftoverChar = cb.get();
            }
            break;
        }
        if (cr.isOverflow()) {
            assert bb.position()  > 0;
            writeBytes();
            continue;
        }
        cr.throwException();
        }
}

 public  void write(int c) throws IOException 
{
        char cbuf[] = new char[1];
        cbuf[0] = (char) c;
        write(cbuf, 0, 1);
}

 public  void write(char[] cbuf,
    int off,
    int len) throws IOException 
{
        synchronized (lock) {
            ensureOpen();
            if ((off <  0) || (off  > cbuf.length) || (len <  0) ||
                ((off + len)  > cbuf.length) || ((off + len) <  0)) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return;
            }
            implWrite(cbuf, off, len);
        }
}

 public  void write(String str,
    int off,
    int len) throws IOException 
{
        /* Check the len before creating a char buffer */
        if (len <  0)
            throw new IndexOutOfBoundsException();
        char cbuf[] = new char[len];
        str.getChars(off, off + len, cbuf, 0);
        write(cbuf, 0, len);
}