ForwardingIMap.java

package com.hazelcast.util;

import com.google.common.collect.ForwardingConcurrentMap;

import com.hazelcast.core.EntryListener;
import com.hazelcast.core.IMap;
import com.hazelcast.core.MapEntry;
import com.hazelcast.monitor.LocalMapStats;
import com.hazelcast.query.Expression;
import com.hazelcast.query.Predicate;

import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;


/**
 * A forwarding class for IMap, which is itself an extension of ConcurrentMap.
 * This is for Hazelcast 1.9 and earlier. For Hazelcast 2.0, see https://pastebin.com/7ng381ZN
 */
public class ForwardingIMap<K, V> extends ForwardingConcurrentMap<K, V> implements IMap<K, V> {

    public ForwardingIMap(IMap<K, V> map) {
        this.map = map;
    }


    //
    // Instance methods
    //

    @Override public InstanceType getInstanceType() {
        return delegate().getInstanceType();
    }

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

    @Override public Object getId() {
        return delegate().getId();
    }


    //
    // IMap methods
    //

    @Override public void flush() {
        delegate().flush();
    }
    @Override public String getName() {
        return delegate().getName();
    }

    @Override public Map<K, V> getAll(Set<K> keys) {
        return delegate().getAll(keys);
    }

    @Override public Future<V> getAsync(K key) {
        return delegate().getAsync(key);
    }

    @Override public Future<V> putAsync(K key, V value) {
        return delegate().putAsync(key, value);
    }

    @Override public Future<V> removeAsync(K key) {
        return delegate().removeAsync(key);
    }

    @Override public Object tryRemove(K key, long timeout, TimeUnit timeunit) throws TimeoutException {
        return delegate().tryRemove(key, timeout, timeunit);
    }

    @Override public boolean tryPut(K key, V value, long timeout, TimeUnit timeunit) {
        return delegate().tryPut(key, value, timeout, timeunit);
    }

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

    @Override public void putTransient(K key, V value, long ttl, TimeUnit timeunit) {
        delegate().putTransient(key, value, ttl, timeunit);
    }

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

    @Override public V tryLockAndGet(K key, long time, TimeUnit timeunit) throws TimeoutException {
        return delegate().tryLockAndGet(key, time, timeunit);
    }

    @Override public void putAndUnlock(K key, V value) {
        delegate().putAndUnlock(key, value);
    }

    @Override public void lock(K key) {
        delegate().lock(key);
    }

    @Override public boolean tryLock(K key) {
        return delegate().tryLock(key);
    }

    @Override public boolean tryLock(K key, long time, TimeUnit timeunit) {
        return delegate().tryLock(key, time, timeunit);
    }

    @Override public void unlock(K key) {
        delegate().unlock(key);
    }

    @Override public boolean lockMap(long time, TimeUnit timeunit) {
        return delegate().lockMap(time, timeunit);
    }

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


    @Override public void addLocalEntryListener(EntryListener<K,V> listener) {
        delegate().addLocalEntryListener(listener);
    }

    @Override public void addEntryListener(EntryListener<K,V> listener, boolean includeValue) {
        delegate().addEntryListener(listener, includeValue);
    }

    @Override public void removeEntryListener(EntryListener<K,V> listener) {
        delegate().removeEntryListener(listener);
    }

    @Override public void addEntryListener(EntryListener<K,V> listener, K key, boolean includeValue) {
        delegate().addEntryListener(listener, key, includeValue);
    }

    @Override public void removeEntryListener(EntryListener<K,V> listener, K key) {
        delegate().removeEntryListener(listener, key);
    }

    @Override public MapEntry<K,V> getMapEntry(K key) {
        return delegate().getMapEntry(key);
    }

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

    @Override public Set<K> keySet(Predicate predicate) {
        return delegate().keySet(predicate);
    }

    @Override public Set<Map.Entry<K,V>> entrySet(Predicate predicate) {
        return delegate().entrySet(predicate);
    }

    @Override public Collection<V> values(Predicate predicate) {
        return delegate().values(predicate);
    }

    @Override public Set<K> localKeySet() {
        return delegate().localKeySet();
    }

    @Override public Set<K> localKeySet(Predicate predicate) {
        return delegate().localKeySet(predicate);
    }

    @Override public void addIndex(String attribute, boolean ordered) {
        delegate().addIndex(attribute, ordered);
    }

    @Override public void addIndex(Expression<?> expression, boolean ordered) {
        delegate().addIndex(expression, ordered);
    }

    @Override public LocalMapStats getLocalMapStats() {
        return delegate().getLocalMapStats();
    }



    protected IMap<K, V> delegate() {
        return map;
    }

    private final IMap<K, V> map;
}