/**
    * Redistribution and use of this software and associated documentation ("Software"), with or
    * without modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright statements and notices. Redistributions
    * must also contain a copy of this document.
    *
    * 2. Redistributions in binary form must reproduce the above copyright notice, this list of
    * conditions and the following disclaimer in the documentation and/or other materials provided with
   * the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote products derived from this Software
   * without prior written permission of Intalio, Inc. For written permission, please contact
   * info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab" nor may "Exolab" appear in
   * their names without prior written permission of Intalio, Inc. Exolab is a registered trademark of
   * Intalio, Inc.
   *
   * 5. Due credit should be given to the Exolab Project (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR
   * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTALIO, INC. OR ITS
   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
   * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 1999 (C) Intalio, Inc. All Rights Reserved.
   */
  package org.exolab.javasource;
  
  import java.io.Writer;
  
  /**
   * The writer used by the javasource classes.
   *
   * @author <a href="mailto:keith AT kvisco DOT com">Keith Visco</a>
   * @version $Revision$ $Date: 2005-03-30 03:29:24 -0700 (Wed, 30 Mar 2005) $
   */
  public final class JSourceWriter extends Writer {
    // --------------------------------------------------------------------------
  
    /** The default character to use for indentation. */
    public static final char DEFAULT_CHAR = ' ';
  
    /** The default indentation size. */
    public static final short DEFAULT_SIZE = 4;
  
    // --------------------------------------------------------------------------
  
    /** The line separator to use for the writeln methods. */
    private String _lineSeparator = System.getProperty("line.separator");
  
    /**
     * Flag for indicating whether we need to add the whitespace to beginning of next write call.
     */
    private boolean _addIndentation = true;
  
    /**
     * A flag indicating whether this JSourceWriter should perform autoflush at the end of a new line.
     */
    private boolean _autoflush = false;
  
    /** The tab (indentation) size. */
    private short _tabSize = DEFAULT_SIZE;
  
    /** The tab representation. */
    private char[] _tab;
  
    /** The character to use for indentation. */
    private char _tabChar = DEFAULT_CHAR;
  
    /** The current tab level. */
    private short _tabLevel = 0;
  
    /** The writer to send all output to. */
    private Writer _out = null;
  
    // --------------------------------------------------------------------------
  
    /**
     * Creates a new JSourceWriter.
     *
     * @param out The Writer to write the actual output to.
     */
    public JSourceWriter(final Writer out) {
      this(out, DEFAULT_SIZE, DEFAULT_CHAR, false);
    }
  
    /**
     * Creates a new JSourceWriter.
     *
     * @param out The Writer to write the actual output to.
     * @param autoflush A boolean indicating whether or not to perform automatic flush at the end of a
     *        line.
     */
   public JSourceWriter(final Writer out, final boolean autoflush) {
     this(out, DEFAULT_SIZE, DEFAULT_CHAR, autoflush);
   }
 
   /**
    * Creates a new JSourceWriter.
    *
    * @param out The Writer to write the actual output to.
    * @param tabSize The size of each indentation.
    * @param autoflush A boolean indicating whether or not to perform automatic flush at the end of a
    *        line.
    */
   public JSourceWriter(final Writer out, final short tabSize, final boolean autoflush) {
     this(out, tabSize, DEFAULT_CHAR, autoflush);
   }
 
   /**
    * Creates a new JSourceWriter.
    *
    * @param out The Writer to write the actual output to.
    * @param tabSize The size of each indentation.
    * @param tabChar The character to use for indentation.
    * @param autoflush A boolean indicating whether or not to perform an automatic flush at the end
    *        of each line.
    */
   public JSourceWriter(final Writer out, final short tabSize, final char tabChar,
       final boolean autoflush) {
     _out = out;
     _autoflush = autoflush;
     _tabChar = tabChar;
     _tabSize = tabSize;
     createTab();
   }
 
   // --------------------------------------------------------------------------
 
   /**
    * Returns the line separator being used by this JSourceWriter.
    *
    * @return The line separator being used by this JSourceWriter.
    */
   public String getLineSeparator() {
     return _lineSeparator;
   }
 
   /**
    * Increases the indentation level by 1.
    */
   public void indent() {
     ++_tabLevel;
   }
 
   /**
    * Checks to see if the cursor is positioned on a new line.
    *
    * @return True if the cursor is at the start of a new line, otherwise false.
    */
   public boolean isNewline() {
     // -- if we need to add indentation, we are on a new line
     return _addIndentation;
   }
 
   /**
    * Sets the line separator to use at the end of each line. Typically a line separator will be one
    * of the following:
    * <ul>
    * <li>"\r\n" for MS Windows</li>
    * <li>"\n" for UNIX</li>
    * <li>"\r" for Macintosh</li>
    * </ul>
    *
    * @param lineSeparator The String to use as a line separator.
    */
   public void setLineSeparator(final String lineSeparator) {
     _lineSeparator = lineSeparator;
   }
 
   /**
    * Decreases the indentation level by 1.
    */
   public void unindent() {
     if (_tabLevel > 0) {
       --_tabLevel;
     }
   }
 
   /**
    * Returns the current indentation level.
    *
    * @return The current indentation level.
    */
   protected short getIndentLevel() {
     return _tabLevel;
   }
 
   /**
    * Returns the current indent size (getIndentLevel()*tabSize).
    *
    * @return The current indent size.
    */
   protected short getIndentSize() {
     return (short) (_tabLevel * _tabSize);
   }
 
   /**
    * Returns the current character used for indentation.
    * 
    * @return The current character used for indentation.
    */
   protected char getIndentChar() {
     return _tabChar;
   }
 
   /**
    * Always applies the current indentation.
    */
   protected void writeIndent() {
     try {
       for (int i = 0; i < _tabLevel; i++) {
         _out.write(_tab);
       }
     } catch (java.io.IOException ioe) {
       // ignore
     }
   }
 
   /**
    * If indentation has not already been applied, then applies it.
    */
   private void ensureIndent() {
     if (_addIndentation) {
       writeIndent();
       _addIndentation = false;
     }
   }
 
   /**
    * Writes the line separator character to the writer.
    */
   private void linefeed() {
     try {
       _out.write(_lineSeparator);
     } catch (java.io.IOException ioe) {
       // ignore
     }
   }
 
   /**
    * Creates the tab from the tabSize and the tabChar.
    */
   private void createTab() {
     _tab = new char[_tabSize];
     for (int i = 0; i < _tabSize; i++) {
       _tab[i] = _tabChar;
     }
   }
 
   // --------------------------------------------------------------------------
 
   public void write(final float f) {
     write(String.valueOf(f));
   }
 
   public void write(final long l) {
     write(String.valueOf(l));
   }
 
   public void write(final double d) {
     write(String.valueOf(d));
   }
 
   public void write(final Object obj) {
     write(obj.toString());
   }
 
   public void write(final boolean b) {
     write(String.valueOf(b));
   }
 
   // --------------------------------------------------------------------------
 
   public void writeln() {
     synchronized (lock) {
       linefeed();
       _addIndentation = true;
     }
   }
 
   public void writeln(final float f) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(String.valueOf(f));
       } catch (java.io.IOException ioe) {
         // ignore
       }
       linefeed();
       _addIndentation = true;
     }
   }
 
   public void writeln(final long l) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(String.valueOf(l));
       } catch (java.io.IOException ioe) {
         // ignore
       }
       linefeed();
       _addIndentation = true;
     }
   }
 
   public void writeln(final int i) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(String.valueOf(i));
       } catch (java.io.IOException ioe) {
         // ignore
       }
       linefeed();
       _addIndentation = true;
     }
   }
 
   public void writeln(final double d) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(String.valueOf(d));
       } catch (java.io.IOException ioe) {
         // ignore
       }
       linefeed();
       _addIndentation = true;
     }
   }
 
   public void writeln(final Object obj) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(obj.toString());
       } catch (java.io.IOException ioe) {
         // ignore
       }
       linefeed();
       _addIndentation = true;
     }
   }
 
   public void writeln(final String string) {
     synchronized (lock) {
       if (string.length() > 0) {
         ensureIndent();
         try {
           _out.write(string);
         } catch (java.io.IOException ioe) {
           // ignore
         }
       }
       linefeed();
       _addIndentation = true;
     }
   }
 
   public void writeln(final char[] chars) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(chars);
       } catch (java.io.IOException ioe) {
         // ignore
       }
       linefeed();
       _addIndentation = true;
     }
   }
 
   public void writeln(final boolean b) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(String.valueOf(b));
       } catch (java.io.IOException ioe) {
         // ignore
       }
       linefeed();
       _addIndentation = true;
     }
   }
 
   public void writeln(final char c) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(c);
       } catch (java.io.IOException ioe) {
         // ignore
       }
       linefeed();
       _addIndentation = true;
     }
   }
 
   // --------------------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    */
   public void close() {
     try {
       _out.close();
     } catch (java.io.IOException ioe) {
       // ignore
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void flush() {
     try {
       _out.flush();
     } catch (java.io.IOException ioe) {
       // ignore
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void write(final String s, final int off, final int len) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(s, off, len);
       } catch (java.io.IOException ioe) {
         // ignore
       }
       if (_autoflush) {
         flush();
       }
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void write(final String s) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(s);
       } catch (java.io.IOException ioe) {
         // ignore
       }
       if (_autoflush) {
         flush();
       }
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void write(final char[] buf) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(buf);
       } catch (java.io.IOException ioe) {
         // ignore
       }
       if (_autoflush) {
         flush();
       }
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void write(final int c) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(c);
       } catch (java.io.IOException ioe) {
         // ignore
       }
       if (_autoflush) {
         flush();
       }
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void write(final char[] buf, final int off, final int len) {
     synchronized (lock) {
       ensureIndent();
       try {
         _out.write(buf, off, len);
       } catch (java.io.IOException ioe) {
         // ignore
       }
       if (_autoflush) {
         flush();
       }
     }
   }
 
   // --------------------------------------------------------------------------
 }