1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 package org.apache.commons.collections4.keyvalue; 18 19 import java.util.Map; 20 21 import org.apache.commons.collections4.KeyValue; 22 23 /** 24 * A mutable {@code KeyValue} pair that does not implement 25 * {@link java.util.Map.Entry Map.Entry}. 26 * <p> 27 * Note that a {@code DefaultKeyValue} instance may not contain 28 * itself as a key or value. 29 * </p> 30 * 31 * @param <K> the type of keys 32 * @param <V> the type of values 33 * @since 3.0 34 */ 35 public class DefaultKeyValue<K, V> extends AbstractKeyValue<K, V> { 36 37 /** 38 * Constructs a new pair with a null key and null value. 39 */ 40 public DefaultKeyValue() { 41 super(null, null); 42 } 43 44 /** 45 * Constructs a new pair with the specified key and given value. 46 * 47 * @param key the key for the entry, may be null 48 * @param value the value for the entry, may be null 49 */ 50 public DefaultKeyValue(final K key, final V value) { 51 super(key, value); 52 } 53 54 /** 55 * Constructs a new pair from the specified {@code KeyValue}. 56 * 57 * @param pair the pair to copy, must not be null 58 * @throws NullPointerException if the entry is null 59 */ 60 public DefaultKeyValue(final KeyValue<? extends K, ? extends V> pair) { 61 super(pair.getKey(), pair.getValue()); 62 } 63 64 /** 65 * Constructs a new pair from the specified {@code Map.Entry}. 66 * 67 * @param entry the entry to copy, must not be null 68 * @throws NullPointerException if the entry is null 69 */ 70 public DefaultKeyValue(final Map.Entry<? extends K, ? extends V> entry) { 71 super(entry.getKey(), entry.getValue()); 72 } 73 74 /** 75 * Compares this {@code Map.Entry} with another {@code Map.Entry}. 76 * <p> 77 * Returns true if the compared object is also a {@code DefaultKeyValue}, 78 * and its key and value are equal to this object's key and value. 79 * 80 * @param obj the object to compare to 81 * @return true if equal key and value 82 */ 83 @Override 84 public boolean equals(final Object obj) { 85 if (obj == this) { 86 return true; 87 } 88 if (!(obj instanceof DefaultKeyValue)) { 89 return false; 90 } 91 92 final DefaultKeyValue<?, ?> other = (DefaultKeyValue<?, ?>) obj; 93 return 94 (getKey() == null ? other.getKey() == null : getKey().equals(other.getKey())) && 95 (getValue() == null ? other.getValue() == null : getValue().equals(other.getValue())); 96 } 97 98 /** 99 * Gets a hashCode compatible with the equals method. 100 * <p> 101 * Implemented per API documentation of {@link java.util.Map.Entry#hashCode()}, 102 * however subclasses may override this. 103 * 104 * @return a suitable hash code 105 */ 106 @Override 107 public int hashCode() { 108 return (getKey() == null ? 0 : getKey().hashCode()) ^ 109 (getValue() == null ? 0 : getValue().hashCode()); 110 } 111 112 /** 113 * Sets the key. 114 * 115 * @param key the new key 116 * @return the old key 117 * @throws IllegalArgumentException if key is this object 118 */ 119 @Override 120 public K setKey(final K key) { 121 if (key == this) { 122 throw new IllegalArgumentException("DefaultKeyValue may not contain itself as a key."); 123 } 124 125 return super.setKey(key); 126 } 127 128 /** 129 * Sets the value. 130 * 131 * @return the old value of the value 132 * @param value the new value 133 * @throws IllegalArgumentException if value is this object 134 */ 135 @Override 136 public V setValue(final V value) { 137 if (value == this) { 138 throw new IllegalArgumentException("DefaultKeyValue may not contain itself as a value."); 139 } 140 141 return super.setValue(value); 142 } 143 144 /** 145 * Returns a new {@code Map.Entry} object with key and value from this pair. 146 * 147 * @return a MapEntry instance 148 */ 149 public Map.Entry<K, V> toMapEntry() { 150 return new DefaultMapEntry<>(this); 151 } 152 153 }