restconf/restconf-common/src/main/java/org/opendaylight/restconf/common/util/MultivaluedHashMap.java

   1 /*
   2  * Copyright (c) 2017 Inocybe Technologies and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.restconf.common.util;
   9
  10 import java.util.Arrays;
  11 import java.util.Collection;
  12 import java.util.HashMap;
  13 import java.util.LinkedList;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Objects;
  17 import java.util.Set;
  18 import javax.ws.rs.core.MultivaluedMap;
  19
  20 /**
  21  * A hash table based implementation of {@link MultivaluedMap} interface.
  22  *
  23  * @deprecated Use {@link javax.ws.rs.core.MultivaluedHashMap} instead.
  24  * @author Thomas Pantelis
  25  */
  26 @Deprecated(since = "2.0.1", forRemoval = true)
  27 // FIXME: 3.0.0: remove this class
  28 public class MultivaluedHashMap<K, V> implements MultivaluedMap<K, V> {
  29     private final Map<K, List<V>> store = new HashMap<>();
  30
  31     @Override
  32     public final void putSingle(K key, V value) {
  33         List<V> values = getValues(key);
  34
  35         values.clear();
  36         if (value != null) {
  37             values.add(value);
  38         }
  39     }
  40
  41     @Override
  42     public void add(K key, V value) {
  43         List<V> values = getValues(key);
  44
  45         if (value != null) {
  46             values.add(value);
  47         }
  48     }
  49
  50     @Override
  51     @SafeVarargs
  52     public final void addAll(K key, V... newValues) {
  53         addAll(key, Arrays.asList(newValues));
  54     }
  55
  56     @Override
  57     public void addAll(K key, List<V> valueList) {
  58         Objects.requireNonNull(valueList, "Supplied list of values must not be null.");
  59
  60         if (valueList.isEmpty()) {
  61             return;
  62         }
  63
  64         List<V> values = getValues(key);
  65         for (V value : valueList) {
  66             if (value != null) {
  67                 values.add(value);
  68             }
  69         }
  70     }
  71
  72     @Override
  73     public void addFirst(K key, V value) {
  74         List<V> values = getValues(key);
  75
  76         if (value != null) {
  77             values.add(0, value);
  78         }
  79     }
  80
  81     @Override
  82     public V getFirst(K key) {
  83         List<V> values = store.get(key);
  84         return values == null || values.isEmpty() ? null : values.get(0);
  85     }
  86
  87     @Override
  88     public boolean equalsIgnoreValueOrder(MultivaluedMap<K, V> omap) {
  89         if (this == omap) {
  90             return true;
  91         }
  92         if (!keySet().equals(omap.keySet())) {
  93             return false;
  94         }
  95         for (Entry<K, List<V>> e : entrySet()) {
  96             List<V> olist = omap.get(e.getKey());
  97             if (e.getValue().size() != olist.size()) {
  98                 return false;
  99             }
 100             for (V v : e.getValue()) {
 101                 if (!olist.contains(v)) {
 102                     return false;
 103                 }
 104             }
 105         }
 106         return true;
 107     }
 108
 109     @Override
 110     public Collection<List<V>> values() {
 111         return store.values();
 112     }
 113
 114     @Override
 115     public int size() {
 116         return store.size();
 117     }
 118
 119     @Override
 120     public List<V> remove(Object key) {
 121         return store.remove(key);
 122     }
 123
 124     @Override
 125     public void putAll(Map<? extends K, ? extends List<V>> map) {
 126         store.putAll(map);
 127     }
 128
 129     @Override
 130     public List<V> put(K key, List<V> value) {
 131         return store.put(key, value);
 132     }
 133
 134     @Override
 135     public Set<K> keySet() {
 136         return store.keySet();
 137     }
 138
 139     @Override
 140     public boolean isEmpty() {
 141         return store.isEmpty();
 142     }
 143
 144     @Override
 145     public List<V> get(Object key) {
 146         return store.get(key);
 147     }
 148
 149     @Override
 150     public Set<Entry<K, List<V>>> entrySet() {
 151         return store.entrySet();
 152     }
 153
 154     @Override
 155     public boolean containsValue(Object value) {
 156         return store.containsValue(value);
 157     }
 158
 159     @Override
 160     public boolean containsKey(Object key) {
 161         return store.containsKey(key);
 162     }
 163
 164     @Override
 165     public void clear() {
 166         store.clear();
 167     }
 168
 169     private List<V> getValues(K key) {
 170         return store.computeIfAbsent(key, k -> new LinkedList<>());
 171     }
 172 }