org.infinispan.commons.util.AbstractDelegatingMap Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of infinispan-commons Show documentation
Infinispan Commons
There is a newer version: 15.1.0.Dev04
package org.infinispan.commons.util;

import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;

public abstract class AbstractDelegatingMap implements Map {

   protected abstract Map delegate();

   @Override
   public V putIfAbsent(K key, V value) {
      return delegate().putIfAbsent(key, value);
   }

   @Override
   public int size() {
      return delegate().size();
   }

   @Override
   public boolean isEmpty() {
      return delegate().isEmpty();
   }

   @Override
   public boolean containsKey(Object key) {
      return delegate().containsKey(key);
   }

   @Override
   public boolean containsValue(Object value) {
      return delegate().containsValue(value);
   }

   @Override
   public V get(Object key) {
      return delegate().get(key);
   }

   @Override
   public V getOrDefault(Object key, V defaultValue) {
      return delegate().getOrDefault(key, defaultValue);
   }

   @Override
   public V put(K key, V value) {
      return delegate().put(key, value);
   }

   @Override
   public V remove(Object key) {
      return delegate().remove(key);
   }

   @Override
   public boolean remove(Object key, Object value) {
      return delegate().remove(key, value);
   }

   @Override
   public boolean replace(K key, V oldValue, V newValue) {
      return delegate().replace(key, oldValue, newValue);
   }

   @Override
   public V replace(K key, V value) {
      return delegate().replace(key, value);
   }

   @Override
   public void replaceAll(BiFunction function) {
      delegate().replaceAll(function);
   }

   @Override
   public V compute(K key, BiFunction remappingFunction) {
      return delegate().compute(key, remappingFunction);
   }

   @Override
   public V computeIfAbsent(K key, Function mappingFunction) {
      return delegate().computeIfAbsent(key, mappingFunction);
   }

   @Override
   public V computeIfPresent(K key, BiFunction remappingFunction) {
      return delegate().computeIfPresent(key, remappingFunction);
   }

   @Override
   public V merge(K key, V value, BiFunction remappingFunction) {
      return delegate().merge(key, value, remappingFunction);
   }

   @Override
   public void forEach(BiConsumer action) {
      delegate().forEach(action);
   }

   @Override
   public void putAll(Map m) {
      delegate().putAll(m);
   }

   @Override
   public void clear() {
      delegate().clear();
   }

   @Override
   public Set keySet() {
      return delegate().keySet();
   }

   @Override
   public Collection values() {
      return delegate().values();
   }

   @Override
   public Set> entrySet() {
      return delegate().entrySet();
   }

}