Logo
Distributed Genetic Programming Framework
print print

File org.sfc.io.MultiplexingWriter.java

Here you can find all the information about the file org.sfc.io.MultiplexingWriter.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-06-06 13:03:01
 * Original Filename: org.sfc.io.MultiplexingWriter.java
 * Version          : 1.0.0
 * Last modification: 2006-06-06
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */

 
package org.sfc.io;

import java.io.IOException;
import java.io.Writer;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

import org.sfc.collections.Collections;

/**
 * The multiplexing writer allows you to multiplex the output that goes
 * into one writer to multiple writers.
 *
 * @author Thomas Weise
 */

public class MultiplexingWriter extends     ReferenceCountedWriter
                                implements  List<Writer>
  { 
/**
 * The internal writer list.
 */

  private final List<Writer>  m_writers ;
  
/**
 * Create a new multiplexing writer.
 */

  public  MultiplexingWriter()
    {
    super();
    this.m_writers = Collections.create_list(-1);
    }
  
/**
 * Write a single character.  The character to be written is contained in
 * the 16 low-order bits of the given integer value; the 16 high-order bits
 * are ignored.
 *
 * <p> Subclasses that intend to support efficient single-character output
 * should override this method.
 *
 * @param p_c  int specifying a character to be written.
 * @exception  IOException  If an I/O error occurs
 */

  @Override
  public final  void write(final int p_c) throws IOException
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.write(p_c);
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    if(l_x != null) throw l_x;
    }

/**
 * Write an array of characters.
 *
 * @param  p_cbuf  Array of characters to be written
 *
 * @exception  IOException  If an I/O error occurs
 */

  @Override
  public final  void write(final  char p_cbuf[]) throws IOException
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.write(p_cbuf);
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    if(l_x != null) throw l_x;
    }

/**
 * Write a portion of an array of characters.
 *
 * @param  p_cbuf  Array of characters
 * @param  p_off   Offset from which to start writing characters
 * @param  p_len   Number of characters to write
 *
 * @exception  IOException  If an I/O error occurs
 */

  @Override
  public final  void write(final  char p_cbuf[],
                           final  int  p_off,
                           final  int  p_len) throws IOException
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.write(p_cbuf, p_off, p_len);
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    if(l_x != null) throw l_x;
    }                           

/**
 * Write a string.
 *
 * @param  p_str  String to be written
 *
 * @exception  IOException  If an I/O error occurs
 */

  @Override
  public final  void write(final  String p_str) throws IOException
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.write(p_str);
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    if(l_x != null) throw l_x;
    }

/**
 * Write a portion of a string.
 *
 * @param  p_str  A String
 * @param  p_off  Offset from which to start writing characters
 * @param  p_len  Number of characters to write
 *
 * @exception  IOException  If an I/O error occurs
 */

  @Override
  public final  void write(final  String p_str,
                           final  int    p_off,
                           final  int    p_len) throws IOException
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.write(p_str, p_off, p_len);
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    if(l_x != null) throw l_x;
    }

/**
 * Appends the specified character sequence to this writer.
 *
 * <p> An invocation of this method of the form <tt>out.append(csq)</tt>
 * behaves in exactly the same way as the invocation
 *
 * <pre>
 *     out.write(csq.toString()) </pre>
 *
 * <p> Depending on the specification of <tt>toString</tt> for the
 * character sequence <tt>csq</tt>, the entire sequence may not be
 * appended. For instance, invoking the <tt>toString</tt> method of a
 * character buffer will return a subsequence whose content depends upon
 * the buffer's position and limit.
 *
 * @param  p_csq
 *         The character sequence to append.  If <tt>csq</tt> is
 *         <tt>null</tt>, then the four characters <tt>"null"</tt> are
 *         appended to this writer.
 *
 * @return  This writer
 *
 * @throws  IOException
 *          If an I/O error occurs
 *
 * @since  1.5
 */

  @Override
  public final  Writer append(final CharSequence p_csq) throws IOException
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.append(p_csq);
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    if(l_x != null) throw l_x;
    return this;
    }

/**
 * Appends a subsequence of the specified character sequence to this writer.
 * <tt>Appendable</tt>.
 *
 * <p> An invocation of this method of the form <tt>out.append(csq, start,
 * end)</tt> when <tt>csq</tt> is not <tt>null</tt> behaves in exactly the
 * same way as the invocation
 *
 * <pre>
 *     out.write(csq.subSequence(start, end).toString()) </pre>
 *
 * @param  p_csq
 *         The character sequence from which a subsequence will be
 *         appended.  If <tt>csq</tt> is <tt>null</tt>, then characters
 *         will be appended as if <tt>csq</tt> contained the four
 *         characters <tt>"null"</tt>.
 *
 * @param  p_start
 *         The index of the first character in the subsequence
 *
 * @param  p_end
 *         The index of the character following the last character in the
 *         subsequence
 *
 * @return  This writer
 *
 * @throws  IndexOutOfBoundsException
 *          If <tt>start</tt> or <tt>end</tt> are negative, <tt>start</tt>
 *          is greater than <tt>end</tt>, or <tt>end</tt> is greater than
 *          <tt>csq.length()</tt>
 *
 * @throws  IOException
 *          If an I/O error occurs
 *
 * @since  1.5
 */

  @Override
  public final  Writer append(final CharSequence p_csq,
                              final int          p_start,
                              final int          p_end) throws IOException 
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.append(p_csq, p_start, p_end);
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    if(l_x != null) throw l_x;
    return this;
    }

/**
 * Appends the specified character to this writer.
 *
 * <p> An invocation of this method of the form <tt>out.append(c)</tt>
 * behaves in exactly the same way as the invocation
 *
 * <pre>
 *     out.write(c) </pre>
 *
 * @param  p_c
 *         The 16-bit character to append
 *
 * @return  This writer
 *
 * @throws  IOException
 *          If an I/O error occurs
 *
 * @since 1.5
 */

  @Override
  public final  Writer append(final char p_c) throws IOException
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.append(p_c);
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    if(l_x != null) throw l_x;
    return this;
    }

/**
 * Flush the stream.  If the stream has saved any characters from the
 * various write() methods in a buffer, write them immediately to their
 * intended destination.  Then, if that destination is another character or
 * byte stream, flush it.  Thus one flush() invocation will flush all the
 * buffers in a chain of Writers and OutputStreams.
 * <p>
 * If the intended destination of this stream is an abstraction provided by
 * the underlying operating system, for example a file, then flushing the
 * stream guarantees only that bytes previously written to the stream are
 * passed to the operating system for writing; it does not guarantee that
 * they are actually written to a physical device such as a disk drive.
 *
 * @exception  IOException  If an I/O error occurs
 */

  @Override
  public final  void flush() throws IOException
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.flush();
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    if(l_x != null) throw l_x;    
    }
  
/**
 * Dispose this reference counted writer.
 * @throws  IOException If the underlying was closed and caused an
 *                      IOException.
 */

  @Override
  protected void  dispose () throws IOException
    {
    IOException l_x;
    
    l_x = null;
    for(Writer l_w : this.m_writers)
      {
      try
        {
        l_w.close();
        }
      catch(IOException l_q)
        {
        l_x = l_q;
        }
      }
    
    this.m_writers.clear();
    super.dispose();
    if(l_x != null) throw l_x;    
    }

/**
 * Return the name of the character encoding being used by this stream.
 *
 * <p> If the encoding has an historical name then that name is returned;
 * otherwise the encoding's canonical name is returned.
 *
 * <p> If this instance was created with the  constructor then the returned
 * name, being unique for the encoding, may differ from the name passed to
 * the constructor.  This method may return <tt>null</tt> if the stream has
 * been closed. </p>
 *
 * @return The historical name of this encoding, or possibly
 *         <code>null</code> if the stream has been closed
 */

  @Override
  public  final String  get_encoding  ()
    {
    String  l_s, l_d;
    
    l_s = null;
    for(Writer l_w : this.m_writers)
      {
      l_d = default_get_encoding(l_w);
      if(l_d != null)
        {
        if(l_s == null) l_s = l_d;
        else if(!(l_s.equals(l_d))) return null;
        }
      }
    
    return ((l_s != null) ? l_s : default_get_encoding(this));
    }
  
  
  
/**
 * Returns the number of elements in this list.  If this list contains
 * more than <tt>Integer.MAX_VALUE</tt> elements, returns
 * <tt>Integer.MAX_VALUE</tt>.
 *
 * @return the number of elements in this list.
 */

  public  final int size()
    {
    return this.m_writers.size();
    }

/**
 * Returns <tt>true</tt> if this list contains no elements.
 *
 * @return <tt>true</tt> if this list contains no elements.
 */

  public  final boolean isEmpty()
    {
    return this.m_writers.isEmpty();
    }

/**
 * 
 * Returns <tt>true</tt> if this list contains the specified element.
 * More formally, returns <tt>true</tt> if and only if this list contains
 * at least one element <tt>e</tt> such that
 * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
 *
 * @param p_o element whose presence in this list is to be tested.
 * @return <tt>true</tt> if this list contains the specified element.
 * @throws ClassCastException if the type of the specified element
 *         is incompatible with this list (optional).
 * @throws NullPointerException if the specified element is null and this
 *         list does not support null elements (optional).
 */

  public  final boolean contains(final Object p_o)
    {
    return this.m_writers.contains(p_o);
    }

/**
 * Returns an iterator over the elements in this list in proper sequence.
 *
 * @return an iterator over the elements in this list in proper sequence.
 */

  public  final Iterator<Writer> iterator()
    {
    return this.m_writers.iterator();
    }

/**
 * Returns an array containing all of the elements in this list in proper
 * sequence.  Obeys the general contract of the
 * <tt>Collection.toArray</tt> method.
 *
 * @return an array containing all of the elements in this list in proper
 *         sequence.
 * @see Arrays#asList(Object[])
 */

  public  final Object[] toArray()
    {
    return this.m_writers.toArray();
    }

/**
 * Returns an array containing all of the elements in this list in proper
 * sequence; the runtime type of the returned array is that of the
 * specified array.  Obeys the general contract of the
 * <tt>Collection.toArray(Object[])</tt> method.
 *
 * @param p_a the array into which the elements of this list are to
 *    be stored, if it is big enough; otherwise, a new array of the
 *    same runtime type is allocated for this purpose.
 * @param <T> The array item type.
 * @return  an array containing the elements of this list.
 * 
 * @throws ArrayStoreException if the runtime type of the specified array
 *      is not a supertype of the runtime type of every element in
 *      this list.
 * @throws NullPointerException if the specified array is <tt>null</tt>.
 */

  public  final <T> T[] toArray(final T[] p_a)
    {
    return this.m_writers.toArray(p_a);
    }


    // Modification Operations

/**
 * Appends the specified element to the end of this list (optional
 * operation). <p>
 *
 * Lists that support this operation may place limitations on what
 * elements may be added to this list.  In particular, some
 * lists will refuse to add null elements, and others will impose
 * restrictions on the type of elements that may be added.  List
 * classes should clearly specify in their documentation any restrictions
 * on what elements may be added.
 *
 * @param p_o element to be appended to this list.
 * @return <tt>true</tt> (as per the general contract of the
 *            <tt>Collection.add</tt> method).
 * 
 * @throws UnsupportedOperationException if the <tt>add</tt> method is not
 *      supported by this list.
 * @throws ClassCastException if the class of the specified element
 *      prevents it from being added to this list.
 * @throws NullPointerException if the specified element is null and this
 *           list does not support null elements.
 * @throws IllegalArgumentException if some aspect of this element
 *            prevents it from being added to this list.
 */

  public  final boolean add(final Writer p_o)
    {
    return this.m_writers.add(p_o);
    }

/**
 * Removes the first occurrence in this list of the specified element 
 * (optional operation).  If this list does not contain the element, it is
 * unchanged.  More formally, removes the element with the lowest index i
 * such that <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt> (if
 * such an element exists).
 *
 * @param p_o element to be removed from this list, if present.
 * @return <tt>true</tt> if this list contained the specified element.
 * @throws ClassCastException if the type of the specified element
 *            is incompatible with this list (optional).
 * @throws NullPointerException if the specified element is null and this
 *            list does not support null elements (optional).
 * @throws UnsupportedOperationException if the <tt>remove</tt> method is
 *      not supported by this list.
 */

  public  final boolean remove(final  Object p_o)
    {
    return this.m_writers.remove(p_o);
    }


    // Bulk Modification Operations

/**
 * 
 * Returns <tt>true</tt> if this list contains all of the elements of the
 * specified collection.
 *
 * @param  p_c collection to be checked for containment in this list.
 * @return <tt>true</tt> if this list contains all of the elements of the
 *         specified collection.
 * @throws ClassCastException if the types of one or more elements
 *         in the specified collection are incompatible with this
 *         list (optional).
 * @throws NullPointerException if the specified collection contains one
 *         or more null elements and this list does not support null
 *         elements (optional).
 * @throws NullPointerException if the specified collection is
 *         <tt>null</tt>.
 * @see #contains(Object)
 */

  public  final boolean containsAll(final Collection<?> p_c)
    {
    return this.m_writers.containsAll(p_c);
    }

/**
 * Appends all of the elements in the specified collection to the end of
 * this list, in the order that they are returned by the specified
 * collection's iterator (optional operation).  The behavior of this
 * operation is unspecified if the specified collection is modified while
 * the operation is in progress.  (Note that this will occur if the
 * specified collection is this list, and it's nonempty.)
 *
 * @param p_c collection whose elements are to be added to this list.
 * @return <tt>true</tt> if this list changed as a result of the call.
 * 
 * @throws UnsupportedOperationException if the <tt>addAll</tt> method is
 *         not supported by this list.
 * @throws ClassCastException if the class of an element in the specified
 *         collection prevents it from being added to this list.
 * @throws NullPointerException if the specified collection contains one
 *         or more null elements and this list does not support null
 *         elements, or if the specified collection is <tt>null</tt>.
 * @throws IllegalArgumentException if some aspect of an element in the
 *         specified collection prevents it from being added to this
 *         list.
 */

  public  final boolean addAll(final  Collection<? extends Writer> p_c)
    {
    return this.m_writers.addAll(p_c);
    }

/**
 * Inserts all of the elements in the specified collection into this
 * list at the specified position (optional operation).  Shifts the
 * element currently at that position (if any) and any subsequent
 * elements to the right (increases their indices).  The new elements
 * will appear in this list in the order that they are returned by the
 * specified collection's iterator.  The behavior of this operation is
 * unspecified if the specified collection is modified while the
 * operation is in progress.  (Note that this will occur if the specified
 * collection is this list, and it's nonempty.)
 *
 * @param p_index index at which to insert first element from the specified
 *              collection.
 * @param p_c elements to be inserted into this list.
 * @return <tt>true</tt> if this list changed as a result of the call.
 * 
 * @throws UnsupportedOperationException if the <tt>addAll</tt> method is
 *      not supported by this list.
 * @throws ClassCastException if the class of one of elements of the
 *      specified collection prevents it from being added to this
 *      list.
 * @throws NullPointerException if the specified collection contains one
 *           or more null elements and this list does not support null
 *           elements, or if the specified collection is <tt>null</tt>.
 * @throws IllegalArgumentException if some aspect of one of elements of
 *      the specified collection prevents it from being added to
 *      this list.
 * @throws IndexOutOfBoundsException if the index is out of range (index
 *      &lt; 0 || index &gt; size()).
 */

  public  final boolean addAll(final  int                          p_index,
                               final  Collection<? extends Writer> p_c)
    {
    return this.m_writers.addAll(p_index, p_c);
    }

/**
 * Removes from this list all the elements that are contained in the
 * specified collection (optional operation).
 *
 * @param p_c collection that defines which elements will be removed from
 *          this list.
 * @return <tt>true</tt> if this list changed as a result of the call.
 * 
 * @throws UnsupportedOperationException if the <tt>removeAll</tt> method
 *      is not supported by this list.
 * @throws ClassCastException if the types of one or more elements
 *            in this list are incompatible with the specified
 *            collection (optional).
 * @throws NullPointerException if this list contains one or more
 *            null elements and the specified collection does not support
 *            null elements (optional).
 * @throws NullPointerException if the specified collection is
 *            <tt>null</tt>.
 * @see #remove(Object)
 * @see #contains(Object)
 */

  public  final boolean removeAll(final Collection<?> p_c)
    {
    return this.m_writers.retainAll(p_c);
    }

/**
 * Retains only the elements in this list that are contained in the
 * specified collection (optional operation).  In other words, removes
 * from this list all the elements that are not contained in the specified
 * collection.
 *
 * @param p_c collection that defines which elements this set will retain.
 * 
 * @return <tt>true</tt> if this list changed as a result of the call.
 * 
 * @throws UnsupportedOperationException if the <tt>retainAll</tt> method
 *      is not supported by this list.
 * @throws ClassCastException if the types of one or more elements
 *            in this list are incompatible with the specified
 *            collection (optional).
 * @throws NullPointerException if this list contains one or more
 *            null elements and the specified collection does not support
 *            null elements (optional).
 * @throws NullPointerException if the specified collection is
 *         <tt>null</tt>.
 * @see #remove(Object)
 * @see #contains(Object)
 */

  public  final boolean retainAll(final Collection<?> p_c)
    {
    return this.m_writers.retainAll(p_c);
    }

/**
 * Removes all of the elements from this list (optional operation).  This
 * list will be empty after this call returns (unless it throws an
 * exception).
 *
 * @throws UnsupportedOperationException if the <tt>clear</tt> method is
 *      not supported by this list.
 */

  public  final void clear()
    {
    this.m_writers.clear();
    }


    


    // Positional Access Operations

/**
 * Returns the element at the specified position in this list.
 *
 * @param p_index index of element to return.
 * @return the element at the specified position in this list.
 * 
 * @throws IndexOutOfBoundsException if the index is out of range (index
 *      &lt; 0 || index &gt;= size()).
 */

  public  final Writer get(final  int p_index)
    {
    return this.m_writers.get(p_index);
    }

/**
 * Replaces the element at the specified position in this list with the
 * specified element (optional operation).
 *
 * @param p_index index of element to replace.
 * @param p_element element to be stored at the specified position.
 * @return the element previously at the specified position.
 * 
 * @throws UnsupportedOperationException if the <tt>set</tt> method is not
 *      supported by this list.
 * @throws    ClassCastException if the class of the specified element
 *      prevents it from being added to this list.
 * @throws    NullPointerException if the specified element is null and
 *            this list does not support null elements.
 * @throws    IllegalArgumentException if some aspect of the specified
 *      element prevents it from being added to this list.
 * @throws    IndexOutOfBoundsException if the index is out of range
 *      (index &lt; 0 || index &gt;= size()).
 */

  public  final Writer set(final  int     p_index,
                           final  Writer  p_element)
    {
    return this.m_writers.set(p_index, p_element);
    }

/**
 * Inserts the specified element at the specified position in this list
 * (optional operation).  Shifts the element currently at that position
 * (if any) and any subsequent elements to the right (adds one to their
 * indices).
 *
 * @param p_index index at which the specified element is to be inserted.
 * @param p_element element to be inserted.
 * 
 * @throws UnsupportedOperationException if the <tt>add</tt> method is not
 *      supported by this list.
 * @throws    ClassCastException if the class of the specified element
 *      prevents it from being added to this list.
 * @throws    NullPointerException if the specified element is null and
 *            this list does not support null elements.
 * @throws    IllegalArgumentException if some aspect of the specified
 *      element prevents it from being added to this list.
 * @throws    IndexOutOfBoundsException if the index is out of range
 *      (index &lt; 0 || index &gt; size()).
 */

  public  final void add(final int    p_index,
                         final Writer p_element)
    {
    this.m_writers.add(p_index, p_element);
    }

/**
 * Removes the element at the specified position in this list (optional
 * operation).  Shifts any subsequent elements to the left (subtracts one
 * from their indices).  Returns the element that was removed from the
 * list.
 *
 * @param p_index the index of the element to removed.
 * @return the element previously at the specified position.
 * 
 * @throws UnsupportedOperationException if the <tt>remove</tt> method is
 *      not supported by this list.
 * @throws IndexOutOfBoundsException if the index is out of range (index
 *            &lt; 0 || index &gt;= size()).
 */

  public  final Writer remove(final int p_index)
    {
    return this.m_writers.remove(p_index);
    }


// Search Operations

/**
 * Returns the index in this list of the first occurrence of the specified
 * element, or -1 if this list does not contain this element.
 * More formally, returns the lowest index <tt>i</tt> such that
 * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
 * or -1 if there is no such index.
 *
 * @param p_o element to search for.
 * @return the index in this list of the first occurrence of the specified
 *         element, or -1 if this list does not contain this element.
 * @throws ClassCastException if the type of the specified element
 *         is incompatible with this list (optional).
 * @throws NullPointerException if the specified element is null and this
 *         list does not support null elements (optional).
 */

  public  final int indexOf(final Object p_o)
    {
    return this.m_writers.indexOf(p_o);
    }

/**
 * Returns the index in this list of the last occurrence of the specified
 * element, or -1 if this list does not contain this element.
 * More formally, returns the highest index <tt>i</tt> such that
 * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
 * or -1 if there is no such index.
 *
 * @param p_o element to search for.
 * @return the index in this list of the last occurrence of the specified
 *         element, or -1 if this list does not contain this element.
 * @throws ClassCastException if the type of the specified element
 *         is incompatible with this list (optional).
 * @throws NullPointerException if the specified element is null and this
 *         list does not support null elements (optional).
 */

  public  final int lastIndexOf(final Object p_o)
    {
    return this.m_writers.lastIndexOf(p_o);
    }


// List Iterators

/**
 * Returns a list iterator of the elements in this list (in proper
 * sequence).
 *
 * @return a list iterator of the elements in this list (in proper
 *         sequence).
 */

  public  final ListIterator<Writer> listIterator()
    {
    return this.m_writers.listIterator();
    }

/**
 * Returns a list iterator of the elements in this list (in proper
 * sequence), starting at the specified position in this list.  The
 * specified index indicates the first element that would be returned by
 * an initial call to the <tt>next</tt> method.  An initial call to
 * the <tt>previous</tt> method would return the element with the
 * specified index minus one.
 *
 * @param p_index index of first element to be returned from the
 *        list iterator (by a call to the <tt>next</tt> method).
 * @return a list iterator of the elements in this list (in proper
 *         sequence), starting at the specified position in this list.
 * @throws IndexOutOfBoundsException if the index is out of range (index
 *         &lt; 0 || index &gt; size()).
 */

  public  final ListIterator<Writer> listIterator(final int p_index)
    {
    return this.m_writers.listIterator(p_index);
    }

    // View

/**
 * Returns a view of the portion of this list between the specified
 * <tt>fromIndex</tt>, inclusive, and <tt>toIndex</tt>, exclusive.  (If
 * <tt>fromIndex</tt> and <tt>toIndex</tt> are equal, the returned list is
 * empty.)  The returned list is backed by this list, so non-structural
 * changes in the returned list are reflected in this list, and vice-versa.
 * The returned list supports all of the optional list operations supported
 * by this list.<p>
 *
 * This method eliminates the need for explicit range operations (of
 * the sort that commonly exist for arrays).   Any operation that expects
 * a list can be used as a range operation by passing a subList view
 * instead of a whole list.  For example, the following idiom
 * removes a range of elements from a list:
 * <pre>
 *      list.subList(from, to).clear();
 * </pre>
 * Similar idioms may be constructed for <tt>indexOf</tt> and
 * <tt>lastIndexOf</tt>, and all of the algorithms in the
 * <tt>Collections</tt> class can be applied to a subList.<p>
 *
 * The semantics of the list returned by this method become undefined if
 * the backing list (i.e., this list) is <i>structurally modified</i> in
 * any way other than via the returned list.  (Structural modifications are
 * those that change the size of this list, or otherwise perturb it in such
 * a fashion that iterations in progress may yield incorrect results.)
 *
 * @param p_from_index low endpoint (inclusive) of the subList.
 * @param p_to_index high endpoint (exclusive) of the subList.
 * @return a view of the specified range within this list.
 * 
 * @throws IndexOutOfBoundsException for an illegal endpoint index value
 *     (fromIndex &lt; 0 || toIndex &gt; size || fromIndex &gt; toIndex).
 */

  public  final List<Writer> subList(final  int p_from_index,
                                     final  int p_to_index)
    {
    return this.m_writers.subList(p_from_index, p_to_index);
    }
  }

File Information:

file name:MultiplexingWriter.java
package:org.sfc.io
qualified name:org.sfc.io.MultiplexingWriter.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/io/MultiplexingWriter.java
size:31.126 KB (31874 B)
uploaded: 2015-07-22 04:11:12 GMT+0000
last update: 2006-06-06 10:31:16 GMT+0000
last access: 2018-01-22 23:50:25 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2018-01-22 23:50:25 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo