Coverage Report - joptsimple.internal.ColumnarData
 
Classes in this File Line Coverage Branch Coverage Complexity
ColumnarData
100%
56/56
91%
20/22
1.818
 
 1   
 /*
 2   
  Copyright 2004-2008 Paul R. Holser, Jr.  All rights reserved.
 3   
  Licensed under the Academic Free License version 3.0
 4   
  */
 5   
 
 6   
 package joptsimple.internal;
 7   
 
 8   
 import java.util.Collections;
 9   
 import java.util.Iterator;
 10   
 import java.util.LinkedList;
 11   
 import java.util.List;
 12   
 
 13   
 /**
 14   
  * <p>A means to display data in a text grid.</p>
 15   
  *
 16   
  * @since 2.1
 17   
  * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
 18   
  * @version $Id: ColumnarData.java,v 1.5 2008/07/15 04:14:56 pholser Exp $
 19   
  */
 20   
 public class ColumnarData {
 21  2 
     private static final String LINE_SEPARATOR = System.getProperty( "line.separator" );
 22   
     private static final int TOTAL_WIDTH = 80;
 23  42 
     private final ColumnWidthCalculator widthCalculator = new ColumnWidthCalculator();
 24  42 
     private final List columns = new LinkedList();
 25   
     private final String[] headers;
 26   
 
 27   
     /**
 28   
      * Creates a new grid with the given column headers.
 29   
      *
 30   
      * @param headers column headers
 31   
      */
 32  42 
     public ColumnarData( String[] headers ) {
 33  42 
         this.headers = (String[]) headers.clone();
 34   
 
 35  42 
         clear();
 36  42 
     }
 37   
 
 38   
     /**
 39   
      * Adds a row to the grid.  The data will fall under the corresponding headers.
 40   
      * There can be fewer elements in the row than headers.  Any data in columns outside
 41   
      * of the number of headers will not be added to the grid.
 42   
      *
 43   
      * @param rowData row data to add
 44   
      */
 45   
     public void addRow( Object[] rowData ) {
 46  82 
         int[] numberOfCellsAddedAt = addRowCells( rowData );
 47  82 
         addPaddingCells( numberOfCellsAddedAt );
 48  82 
     }
 49   
 
 50   
     /**
 51   
      * Gives a string that represents the data formatted in columns.
 52   
      *
 53   
      * @return the formatted grid
 54   
      */
 55   
     public String format() {
 56  36 
         StringBuffer buffer = new StringBuffer();
 57   
 
 58  36 
         writeHeadersOn( buffer );
 59  36 
         writeSeparatorsOn( buffer );
 60  36 
         writeRowsOn( buffer );
 61   
 
 62  36 
         return buffer.toString();
 63   
     }
 64   
 
 65   
     /**
 66   
      * Removes all data from the grid, but preserves the headers.
 67   
      */
 68   
     public final void clear() {
 69  78 
         columns.clear();
 70   
 
 71  78 
         int desiredColumnWidth = widthCalculator.calculate( TOTAL_WIDTH, headers.length );
 72  234 
         for ( int i = 0; i < headers.length; i++ )
 73  156 
             columns.add( new Column( headers[ i ], desiredColumnWidth ) );
 74  78 
     }
 75   
 
 76   
     private void writeHeadersOn( StringBuffer buffer ) {
 77  36 
         for ( Iterator iter = columns.iterator(); iter.hasNext(); )
 78  72 
             ( (Column) iter.next() ).writeHeaderOn( buffer, iter.hasNext() );
 79   
 
 80  36 
         buffer.append( LINE_SEPARATOR );
 81  36 
     }
 82   
 
 83   
     private void writeSeparatorsOn( StringBuffer buffer ) {
 84  36 
         for ( Iterator iter = columns.iterator(); iter.hasNext(); )
 85  72 
             ( (Column) iter.next() ).writeSeparatorOn( buffer, iter.hasNext() );
 86   
 
 87  36 
         buffer.append( LINE_SEPARATOR );
 88  36 
     }
 89   
 
 90   
     private void writeRowsOn( StringBuffer buffer ) {
 91  36 
         int maxHeight =
 92   
             ( (Column) Collections.max( columns, Column.BY_HEIGHT ) ).height();
 93   
 
 94  160 
         for ( int i = 0; i < maxHeight; ++i )
 95  124 
             writeRowOn( buffer, i );
 96  36 
     }
 97   
 
 98   
     private void writeRowOn( StringBuffer buffer, int rowIndex ) {
 99  124 
         for ( Iterator iter = columns.iterator(); iter.hasNext(); )
 100  248 
             ( (Column) iter.next() ).writeCellOn( rowIndex, buffer, iter.hasNext() );
 101   
 
 102  124 
         buffer.append( LINE_SEPARATOR );
 103  124 
     }
 104   
 
 105   
     private int max( int[] numbers ) {
 106  82 
         int maximum = Integer.MIN_VALUE;
 107   
 
 108  246 
         for ( int i = 0; i < numbers.length; ++i )
 109  164 
             maximum = Math.max( maximum, numbers[ i ] );
 110   
 
 111  82 
         return maximum;
 112   
     }
 113   
 
 114   
     private int[] addRowCells( Object[] rowData ) {
 115  82 
         int[] cellsAddedAt = new int[ rowData.length ];
 116   
 
 117  82 
         int i = 0;
 118  82 
         for ( Iterator iter = columns.iterator();
 119  246 
             iter.hasNext() && i < rowData.length;
 120  164 
             ++i ) {
 121   
 
 122  164 
             cellsAddedAt[ i ] = ( (Column) iter.next() ).addCells( rowData[ i ] );
 123   
         }
 124   
 
 125  82 
         return cellsAddedAt;
 126   
     }
 127   
 
 128   
     private void addPaddingCells( int[] numberOfCellsAddedAt ) {
 129  82 
         int maxHeight = max( numberOfCellsAddedAt );
 130   
 
 131  82 
         int i = 0;
 132  82 
         for ( Iterator iter = columns.iterator();
 133  246 
             iter.hasNext() && i < numberOfCellsAddedAt.length;
 134  164 
             ++i ) {
 135   
 
 136  164 
             Column nextColumn = (Column) iter.next();
 137  214 
             for ( int j = 0 ; j < maxHeight - numberOfCellsAddedAt[ i ]; ++j )
 138  50 
                 nextColumn.addCell( "" );
 139   
         }
 140  82 
     }
 141   
 }
Report generated by Cobertura 1.9 on 7/15/08 6:10 PM.