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  * @author Thomas Pantelis
  24  */
  25 public class MultivaluedHashMap<K, V> implements MultivaluedMap<K, V> {
  26     private final Map<K, List<V>> store = new HashMap<>();
  27
  28     @Override
  29     public final void putSingle(K key, V value) {
  30         List<V> values = getValues(key);
  31
  32         values.clear();
  33         if (value != null) {
  34             values.add(value);
  35         }
  36     }
  37
  38     @Override
  39     public void add(K key, V value) {
  40         List<V> values = getValues(key);
  41
  42         if (value != null) {
  43             values.add(value);
  44         }
  45     }
  46
  47     @Override
  48     @SafeVarargs
  49     public final void addAll(K key, V... newValues) {
  50         addAll(key, Arrays.asList(newValues));
  51     }
  52
  53     @Override
  54     public void addAll(K key, List<V> valueList) {
  55         Objects.requireNonNull(valueList, "Supplied list of values must not be null.");
  56
  57         if (valueList.isEmpty()) {
  58             return;
  59         }
  60
  61         List<V> values = getValues(key);
  62         for (V value : valueList) {
  63             if (value != null) {
  64                 values.add(value);
  65             }
  66         }
  67     }
  68
  69     @Override
  70     public void addFirst(K key, V value) {
  71         List<V> values = getValues(key);
  72
  73         if (value != null) {
  74             values.add(0, value);
  75         }
  76     }
  77
  78     @Override
  79     public V getFirst(K key) {
  80         List<V> values = store.get(key);
  81         if (values != null && values.size() > 0) {
  82             return values.get(0);
  83         } else {
  84             return null;
  85         }
  86     }
  87
  88     @Override
  89     public boolean equalsIgnoreValueOrder(MultivaluedMap<K, V> omap) {
  90         if (this == omap) {
  91             return true;
  92         }
  93         if (!keySet().equals(omap.keySet())) {
  94             return false;
  95         }
  96         for (Entry<K, List<V>> e : entrySet()) {
  97             List<V> olist = omap.get(e.getKey());
  98             if (e.getValue().size() != olist.size()) {
  99                 return false;
 100             }
 101             for (V v : e.getValue()) {
 102                 if (!olist.contains(v)) {
 103                     return false;
 104                 }
 105             }
 106         }
 107         return true;
 108     }
 109
 110     @Override
 111     public Collection<List<V>> values() {
 112         return store.values();
 113     }
 114
 115     @Override
 116     public int size() {
 117         return store.size();
 118     }
 119
 120     @Override
 121     public List<V> remove(Object key) {
 122         return store.remove(key);
 123     }
 124
 125     @Override
 126     public void putAll(Map<? extends K, ? extends List<V>> map) {
 127         store.putAll(map);
 128     }
 129
 130     @Override
 131     public List<V> put(K key, List<V> value) {
 132         return store.put(key, value);
 133     }
 134
 135     @Override
 136     public Set<K> keySet() {
 137         return store.keySet();
 138     }
 139
 140     @Override
 141     public boolean isEmpty() {
 142         return store.isEmpty();
 143     }
 144
 145     @Override
 146     public List<V> get(Object key) {
 147         return store.get(key);
 148     }
 149
 150     @Override
 151     public Set<Entry<K, List<V>>> entrySet() {
 152         return store.entrySet();
 153     }
 154
 155     @Override
 156     public boolean containsValue(Object value) {
 157         return store.containsValue(value);
 158     }
 159
 160     @Override
 161     public boolean containsKey(Object key) {
 162         return store.containsKey(key);
 163     }
 164
 165     @Override
 166     public void clear() {
 167         store.clear();
 168     }
 169
 170     private List<V> getValues(K key) {
 171         return store.computeIfAbsent(key, k -> new LinkedList<>());
 172     }
 173 }