Clover coverage report - JGAP 3.1
Coverage timestamp: Mo Dez 11 2006 21:16:18 CET
file stats: LOC: 298   Methods: 15
NCLOC: 141   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
KeyedValues2D.java 100% 93% 93,3% 94,9%
coverage coverage
 1    /*
 2    * This file is part of JGAP.
 3    *
 4    * JGAP offers a dual license model containing the LGPL as well as the MPL.
 5    *
 6    * For licencing information please see the file license.txt included with JGAP
 7    * or have a look at the top of class org.jgap.Chromosome which representatively
 8    * includes the JGAP license policy applicable for any file delivered with JGAP.
 9    */
 10    package org.jgap.audit;
 11   
 12    import java.io.*;
 13    import java.util.*;
 14   
 15    /**
 16    * A collection of (row, column) tupels
 17    *
 18    * @author Klaus Meffert
 19    * @since 2.3
 20    */
 21    public class KeyedValues2D
 22    implements Cloneable, Serializable {
 23    /** String containing the CVS revision. Read out via reflection!*/
 24    private static final String CVS_REVISION = "$Revision: 1.4 $";
 25   
 26    /** The row keys */
 27    private List m_rowKeys;
 28   
 29    /** The column keys */
 30    private List m_columnKeys;
 31   
 32    /** The row data */
 33    private List m_rows;
 34   
 35    /** Should row keys be sorted by their comparable order? */
 36    private boolean m_sortRowKeys;
 37   
 38    /**
 39    * Constructor setting behavior: non-sorted keys
 40    *
 41    * @author Klaus Meffert
 42    * @since 2.3
 43    */
 44  42 public KeyedValues2D() {
 45  42 this(false);
 46    }
 47   
 48    /**
 49    * Constructor.
 50    *
 51    * @param a_sortRowKeys true: row keys should be sorted
 52    *
 53    * @author Klaus Meffert
 54    * @since 2.3
 55    */
 56  44 public KeyedValues2D(final boolean a_sortRowKeys) {
 57  44 m_rowKeys = Collections.synchronizedList(new ArrayList());
 58  44 m_columnKeys = Collections.synchronizedList(new ArrayList());
 59  44 m_rows = Collections.synchronizedList(new ArrayList());
 60  44 m_sortRowKeys = a_sortRowKeys;
 61    }
 62   
 63    /**
 64    * @return the number of rows
 65    *
 66    * @author Klaus Meffert
 67    * @since 2.3
 68    */
 69  20 public int getRowCount() {
 70  20 return m_rowKeys.size();
 71    }
 72   
 73    /**
 74    * @return the number of columns
 75    *
 76    * @author Klaus Meffert
 77    * @since 2.3
 78    */
 79  20 public int getColumnCount() {
 80  20 return m_columnKeys.size();
 81    }
 82   
 83    /**
 84    * Returns the value for a given row and column
 85    *
 86    * @param a_row the row index
 87    * @param a_column the column index
 88    *
 89    * @return value at given row and column
 90    *
 91    * @author Klaus Meffert
 92    * @since 2.3
 93    */
 94  13 public Number getValue(final int a_row, final int a_column) {
 95  13 Number result = null;
 96  13 final KeyedValues rowData = (KeyedValues) m_rows.get(a_row);
 97  13 final Comparable columnKey = (Comparable) m_columnKeys.get(a_column);
 98  13 if (columnKey != null) {
 99  11 result = rowData.getValue(columnKey);
 100    }
 101  13 return result;
 102    }
 103   
 104    /**
 105    * @param a_row the row index, starting at 0
 106    *
 107    * @return key for the given row
 108    *
 109    * @author Klaus Meffert
 110    * @since 2.3
 111    */
 112  24 public Comparable getRowKey(final int a_row) {
 113  24 return (Comparable) m_rowKeys.get(a_row);
 114    }
 115   
 116    /**
 117    * @param a_key the row key
 118    *
 119    * @return row index for the given key
 120    *
 121    * @author Klaus Meffert
 122    * @since 2.3
 123    */
 124  62 public int getRowIndex(final Comparable a_key) {
 125  62 if (m_sortRowKeys) {
 126  4 return Collections.binarySearch(m_rowKeys, a_key);
 127    }
 128    else {
 129  58 return m_rowKeys.indexOf(a_key);
 130    }
 131    }
 132   
 133    /**
 134    * @return row keys
 135    *
 136    * @author Klaus Meffert
 137    * @since 2.3
 138    */
 139  16 public List getRowKeys() {
 140  16 return Collections.unmodifiableList(m_rowKeys);
 141    }
 142   
 143    /**
 144    * @param a_column the column
 145    *
 146    * @return key for the given column
 147    *
 148    * @author Klaus Meffert
 149    * @since 2.3
 150    */
 151  20 public Comparable getColumnKey(final int a_column) {
 152  20 return (Comparable) m_columnKeys.get(a_column);
 153    }
 154   
 155    /**
 156    * @return the column keys
 157    *
 158    * @author Klaus Meffert
 159    * @since 2.3
 160    */
 161  12 public List getColumnKeys() {
 162  12 return Collections.unmodifiableList(m_columnKeys);
 163    }
 164   
 165    /**
 166    * @param a_rowKey the row key
 167    * @param a_columnKey the column key
 168    *
 169    * @return value for the given row and column keys
 170    *
 171    * @author Klaus Meffert
 172    * @since 2.3
 173    */
 174  27 public Number getValue(final Comparable a_rowKey,
 175    final Comparable a_columnKey) {
 176  27 Number result;
 177  27 final int row = getRowIndex(a_rowKey);
 178  27 if (row >= 0) {
 179  22 final KeyedValues rowData = (KeyedValues) m_rows.get(row);
 180  22 result = rowData.getValue(a_columnKey);
 181    }
 182    else {
 183  5 result = null;
 184    }
 185  27 return result;
 186    }
 187   
 188    /**
 189    * Sets a value
 190    *
 191    * @param a_value the value
 192    * @param a_rowKey the row key
 193    * @param a_columnKey the column key
 194    *
 195    * @author Klaus Meffert
 196    * @since 2.3
 197    */
 198  35 public void setValue(final Number a_value, final Comparable a_rowKey,
 199    final Comparable a_columnKey) {
 200  35 final KeyedValues row;
 201  35 int rowIndex = getRowIndex(a_rowKey);
 202  35 if (rowIndex >= 0) {
 203  4 row = (KeyedValues) m_rows.get(rowIndex);
 204    }
 205    else {
 206  31 row = new KeyedValues();
 207  31 if (m_sortRowKeys) {
 208  2 rowIndex = -rowIndex - 1;
 209  2 m_rowKeys.add(rowIndex, a_rowKey);
 210  2 m_rows.add(rowIndex, row);
 211    }
 212    else {
 213  29 m_rowKeys.add(a_rowKey);
 214  29 m_rows.add(row);
 215    }
 216    }
 217  35 row.setValue(a_columnKey, a_value);
 218  35 final int columnIndex = m_columnKeys.indexOf(a_columnKey);
 219  35 if (columnIndex < 0) {
 220  29 m_columnKeys.add(a_columnKey);
 221    }
 222    }
 223   
 224    /**
 225    * Tests if this object is equal to another
 226    *
 227    * @param a_object other object.
 228    *
 229    * @return true: this object is equal to the other one
 230    *
 231    * @author Klaus Meffert
 232    * @since 2.3
 233    */
 234  11 public boolean equals(final Object a_object) {
 235  11 if (a_object == null) {
 236  1 return false;
 237    }
 238  10 if (a_object == this) {
 239  1 return true;
 240    }
 241  9 if (! (a_object instanceof KeyedValues2D)) {
 242  1 return false;
 243    }
 244  8 final KeyedValues2D kv2D = (KeyedValues2D) a_object;
 245  8 if (!getRowKeys().equals(kv2D.getRowKeys())) {
 246  2 return false;
 247    }
 248  6 if (!getColumnKeys().equals(kv2D.getColumnKeys())) {
 249  2 return false;
 250    }
 251  4 int rowCount = getRowCount();
 252  4 int colCount = getColumnCount();
 253  4 for (int r = 0; r < rowCount; r++) {
 254  4 for (int c = 0; c < colCount; c++) {
 255  4 final Number v1 = getValue(r, c);
 256  4 final Number v2 = kv2D.getValue(r, c);
 257  4 if (v1 == null) {
 258  2 if (v2 != null) {
 259  1 return false;
 260    }
 261    }
 262    else {
 263  2 if (!v1.equals(v2)) {
 264  1 return false;
 265    }
 266    }
 267    }
 268    }
 269  2 return true;
 270    }
 271   
 272    /**
 273    * @return hash code of the instance
 274    *
 275    * @author Klaus Meffert
 276    * @since 2.3
 277    */
 278  0 public int hashCode() {
 279  0 int result;
 280  0 result = m_rowKeys.hashCode();
 281  0 result = 29 * result + m_columnKeys.hashCode();
 282  0 result = 31 * result + m_rows.hashCode();
 283  0 return result;
 284    }
 285   
 286    /**
 287    * @return clone of the current instance
 288    *
 289    * @throws CloneNotSupportedException not thrown here
 290    *
 291    * @author Klaus Meffert
 292    * @since 2.3
 293    */
 294  1 public Object clone()
 295    throws CloneNotSupportedException {
 296  1 return super.clone();
 297    }
 298    }