Coverage report

  %line %branch
org.apache.commons.net.io.CopyStreamAdapter
0% 
0% 

 1   
 /*
 2   
  * Copyright 2001-2005 The Apache Software Foundation
 3   
  *
 4   
  * Licensed under the Apache License, Version 2.0 (the "License");
 5   
  * you may not use this file except in compliance with the License.
 6   
  * You may obtain a copy of the License at
 7   
  *
 8   
  *     http://www.apache.org/licenses/LICENSE-2.0
 9   
  *
 10   
  * Unless required by applicable law or agreed to in writing, software
 11   
  * distributed under the License is distributed on an "AS IS" BASIS,
 12   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13   
  * See the License for the specific language governing permissions and
 14   
  * limitations under the License.
 15   
  */
 16   
 package org.apache.commons.net.io;
 17   
 
 18   
 import java.util.Enumeration;
 19   
 import org.apache.commons.net.util.ListenerList;
 20   
 
 21   
 /**
 22   
  * The CopyStreamAdapter will relay CopyStreamEvents to a list of listeners
 23   
  * when either of its bytesTransferred() methods are called.  Its purpose
 24   
  * is to facilitate the notification of the progress of a copy operation
 25   
  * performed by one of the static copyStream() methods in
 26   
  * org.apache.commons.io.Util to multiple listeners.  The static
 27   
  * copyStream() methods invoke the
 28   
  * bytesTransfered(long, int) of a CopyStreamListener for performance
 29   
  * reasons and also because multiple listeners cannot be registered given
 30   
  * that the methods are static.
 31   
  * <p>
 32   
  * <p>
 33   
  * @see CopyStreamEvent
 34   
  * @see CopyStreamListener
 35   
  * @see Util
 36   
  * @author <a href="mailto:savarese@apache.org">Daniel F. Savarese</a>
 37   
  * @version $Id: CopyStreamAdapter.java 165675 2005-05-02 20:09:55Z rwinston $
 38   
  */
 39   
 public class CopyStreamAdapter implements CopyStreamListener
 40   
 {
 41   
     private ListenerList internalListeners;
 42   
 
 43   
     /**
 44   
      * Creates a new copyStreamAdapter.
 45   
      */
 46   
     public CopyStreamAdapter()
 47  0 
     {
 48  0 
         internalListeners = new ListenerList();
 49  0 
     }
 50   
 
 51   
     /**
 52   
      * This method is invoked by a CopyStreamEvent source after copying
 53   
      * a block of bytes from a stream.  The CopyStreamEvent will contain
 54   
      * the total number of bytes transferred so far and the number of bytes
 55   
      * transferred in the last write.  The CopyStreamAdapater will relay
 56   
      * the event to all of its registered listeners, listing itself as the
 57   
      * source of the event.
 58   
      * @param event The CopyStreamEvent fired by the copying of a block of
 59   
      *              bytes.
 60   
      */
 61   
     public void bytesTransferred(CopyStreamEvent event)
 62   
     {
 63  0 
         bytesTransferred(event.getTotalBytesTransferred(),
 64   
                          event.getBytesTransferred(),
 65   
                          event.getStreamSize());
 66  0 
     }
 67   
 
 68   
     /**
 69   
      * This method is not part of the JavaBeans model and is used by the
 70   
      * static methods in the org.apache.commons.io.Util class for efficiency.
 71   
      * It is invoked after a block of bytes to inform the listener of the
 72   
      * transfer.  The CopyStreamAdapater will create a CopyStreamEvent
 73   
      * from the arguments and relay the event to all of its registered
 74   
      * listeners, listing itself as the source of the event.
 75   
      * @param totalBytesTransferred  The total number of bytes transferred
 76   
      *         so far by the copy operation.
 77   
      * @param bytesTransferred  The number of bytes copied by the most recent
 78   
      *          write.
 79   
      * @param streamSize The number of bytes in the stream being copied.
 80   
      *        This may be equal to CopyStreamEvent.UNKNOWN_STREAM_SIZE if
 81   
      *        the size is unknown.
 82   
      */
 83   
     public void bytesTransferred(long totalBytesTransferred,
 84   
                                  int bytesTransferred, long streamSize)
 85   
     {
 86   
         Enumeration listeners;
 87   
         CopyStreamEvent event;
 88   
 
 89  0 
         listeners = internalListeners.getListeners();
 90   
 
 91  0 
         event = new CopyStreamEvent(this,
 92   
                                     totalBytesTransferred,
 93   
                                     bytesTransferred,
 94   
                                     streamSize);
 95   
 
 96  0 
         while (listeners.hasMoreElements())
 97   
         {
 98  0 
             ((CopyStreamListener) (listeners.nextElement())).
 99   
                 bytesTransferred(event);
 100   
         }
 101  0 
     }
 102   
 
 103   
     /**
 104   
      * Registers a CopyStreamListener to receive CopyStreamEvents.
 105   
      * Although this method is not declared to be synchronized, it is
 106   
      * implemented in a thread safe manner.
 107   
      * @param listener  The CopyStreamlistener to register.
 108   
      */
 109   
     public void addCopyStreamListener(CopyStreamListener listener)
 110   
     {
 111  0 
         internalListeners.addListener(listener);
 112  0 
     }
 113   
 
 114   
     /**
 115   
      * Unregisters a CopyStreamListener.  Although this method is not
 116   
      * synchronized, it is implemented in a thread safe manner.
 117   
      * @param listener  The CopyStreamlistener to unregister.
 118   
      */
 119   
     public void removeCopyStreamListener(CopyStreamListener listener)
 120   
     {
 121  0 
         internalListeners.removeListener(listener);
 122  0 
     }
 123   
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.