Clover coverage report - JGAP 3.1
Coverage timestamp: Mo Dez 11 2006 21:16:18 CET
file stats: LOC: 259   Methods: 11
NCLOC: 141   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
KeyedValues.java 82,5% 92,1% 100% 89,8%
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 (key, value) tupels
 17    *
 18    * @author Klaus Meffert
 19    * @since 2.3
 20    */
 21    public class KeyedValues
 22    implements Cloneable, Serializable {
 23    /** String containing the CVS revision. Read out via reflection!*/
 24    private static final String CVS_REVISION = "$Revision: 1.5 $";
 25   
 26    /** Data storage */
 27    private List m_data;
 28   
 29    /**
 30    * Creates a new collection (initially empty).
 31    *
 32    * @author Klaus Meffert
 33    * @since 2.3
 34    */
 35  50 public KeyedValues() {
 36  50 m_data = Collections.synchronizedList(new ArrayList());
 37    }
 38   
 39    /**
 40    * @return number of items in the collection
 41    *
 42    * @author Klaus Meffert
 43    * @since 2.3
 44    */
 45  7 public int size() {
 46  7 return m_data.size();
 47    }
 48   
 49    /**
 50    * @param a_index the index of the item to return the value for
 51    * @return the value at given index
 52    *
 53    * @author Klaus Meffert
 54    * @since 2.3
 55    */
 56  45 public Number getValue(final int a_index) {
 57  45 Number result;
 58  45 final KeyedValue kval = (KeyedValue) m_data.get(a_index);
 59  44 if (kval != null) {
 60  44 result = kval.getValue();
 61    }
 62    else {
 63  0 result = null;
 64    }
 65  44 return result;
 66    }
 67   
 68    /**
 69    * @param a_index the item index to retrieve the key for, starting at 0
 70    *
 71    * @return the row key for item at given index
 72    *
 73    * @author Klaus Meffert
 74    * @since 2.3
 75    */
 76  11 public Comparable getKey(final int a_index) {
 77  11 Comparable result;
 78  11 final KeyedValue item = (KeyedValue) m_data.get(a_index);
 79  10 if (item != null) {
 80  10 result = item.getKey();
 81    }
 82    else {
 83  0 result = null;
 84    }
 85  10 return result;
 86    }
 87   
 88    /**
 89    * @param a_key the key to search for
 90    *
 91    * @return index for a given key or -1 if the key is not found
 92    *
 93    * @author Klaus Meffert
 94    * @since 2.3
 95    */
 96  96 public int getIndex(final Comparable a_key) {
 97  96 int i = 0;
 98  96 final Iterator iterator = m_data.iterator();
 99  96 while (iterator.hasNext()) {
 100  52 final KeyedValue kv = (KeyedValue) iterator.next();
 101  52 if (kv.getKey() != null) {
 102  49 if (kv.getKey().equals(a_key)) {
 103  40 return i;
 104    }
 105    }
 106    else {
 107  3 if (a_key == null) {
 108  2 return i;
 109    }
 110    }
 111  10 i++;
 112    }
 113    // key not found
 114  54 return -1;
 115    }
 116   
 117    /**
 118    * Returns the keys for the values in the collection
 119    *
 120    * @return The keys (never null)
 121    *
 122    * @author Klaus Meffert
 123    * @since 2.3
 124    */
 125  2 public List getKeys() {
 126  2 final List result = new java.util.ArrayList();
 127  2 final Iterator iterator = m_data.iterator();
 128  2 while (iterator.hasNext()) {
 129  3 final KeyedValue kv = (KeyedValue) iterator.next();
 130  3 result.add(kv.getKey());
 131    }
 132  2 return result;
 133    }
 134   
 135    /**
 136    * Returns the value for a given key. For unknown keys, null is returned
 137    *
 138    * @param a_key the key
 139    *
 140    * @return the value for the key
 141    *
 142    * @author Klaus Meffert
 143    * @since 2.3
 144    */
 145  39 public Number getValue(final Comparable a_key) {
 146  39 Number result;
 147  39 final int index = getIndex(a_key);
 148  39 if (index >= 0) {
 149  36 result = getValue(index);
 150    }
 151    else {
 152  3 result = null;
 153    }
 154  39 return result;
 155    }
 156   
 157    /**
 158    * Updates an existing value, or adds a new value to the collection
 159    *
 160    * @param a_key the key
 161    * @param a_value the value
 162    *
 163    * @author Klaus Meffert
 164    * @since 2.3
 165    */
 166  54 public void setValue(final Comparable a_key, final Number a_value) {
 167  54 final int keyIndex = getIndex(a_key);
 168  54 if (keyIndex >= 0) {
 169  5 final KeyedValue kv = (KeyedValue) m_data.get(keyIndex);
 170  5 kv.setValue(a_value);
 171    }
 172    else {
 173  49 final KeyedValue kv = new KeyedValue(a_key, a_value);
 174  49 m_data.add(kv);
 175    }
 176    }
 177   
 178    /**
 179    * Tests if this object is equal to another
 180    *
 181    * @param a_obj the other object
 182    *
 183    * @return true: this object is equal to the other one
 184    *
 185    * @author Klaus Meffert
 186    * @since 2.3
 187    */
 188  6 public boolean equals(final Object a_obj) {
 189  6 if (a_obj == null) {
 190  1 return false;
 191    }
 192  5 if (a_obj == this) {
 193  1 return true;
 194    }
 195  4 if (! (a_obj instanceof KeyedValues)) {
 196  1 return false;
 197    }
 198  3 final KeyedValues kvs = (KeyedValues) a_obj;
 199  3 final int count = size();
 200  3 if (count != kvs.size()) {
 201  2 return false;
 202    }
 203  1 for (int i = 0; i < count; i++) {
 204  2 final Comparable k1 = getKey(i);
 205  2 final Comparable k2 = kvs.getKey(i);
 206  2 if (!k1.equals(k2)) {
 207  0 return false;
 208    }
 209  2 final Number v1 = getValue(i);
 210  2 final Number v2 = kvs.getValue(i);
 211  2 if (v1 == null) {
 212  0 if (v2 != null) {
 213  0 return false;
 214    }
 215    }
 216    else {
 217  2 if (!v1.equals(v2)) {
 218  0 return false;
 219    }
 220    }
 221    }
 222  1 return true;
 223    }
 224   
 225    /**
 226    * @return hash code of the instance
 227    *
 228    * @author Klaus Meffert
 229    * @since 2.3
 230    */
 231  2 public int hashCode() {
 232  2 if (m_data.size() == 0) {
 233  1 return -29;
 234    }
 235    else {
 236  1 return m_data.hashCode();
 237    }
 238    }
 239   
 240    /**
 241    * @return clone of the current instance
 242    *
 243    * @throws CloneNotSupportedException not thrown here
 244    *
 245    * @author Klaus Meffert
 246    * @since 2.3
 247    */
 248  1 public Object clone()
 249    throws CloneNotSupportedException {
 250  1 final KeyedValues clone = (KeyedValues)super.clone();
 251  1 clone.m_data = Collections.synchronizedList(new ArrayList());
 252  1 final Iterator iterator = m_data.iterator();
 253  1 while (iterator.hasNext()) {
 254  2 final KeyedValue kv = (KeyedValue) iterator.next();
 255  2 clone.m_data.add(kv.clone());
 256    }
 257  1 return clone;
 258    }
 259    }