core/api/src/test/java/org/onosproject/store/primitives/AsyncConsistentTreeMapAdapter.java

/*
 * Copyright 2018-present Open Networking Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.onosproject.store.primitives;

import com.google.common.collect.Maps;
import org.onosproject.core.ApplicationId;
import org.onosproject.store.service.AsyncConsistentTreeMap;
import org.onosproject.store.service.AsyncIterator;
import org.onosproject.store.service.ConsistentMap;
import org.onosproject.store.service.ConsistentTreeMap;
import org.onosproject.store.service.MapEventListener;
import org.onosproject.store.service.TransactionLog;
import org.onosproject.store.service.Version;
import org.onosproject.store.service.Versioned;

import java.util.AbstractMap;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.Set;
import java.util.TreeMap;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class AsyncConsistentTreeMapAdapter<V> implements AsyncConsistentTreeMap<V> {

    private TreeMap<String, V> map = Maps.newTreeMap();

    private CompletableFuture<Map.Entry<String, Versioned<V>>> makeVersionedEntry(Map.Entry<String, V> entry) {
        return CompletableFuture.completedFuture(
                new AbstractMap.SimpleImmutableEntry<>(entry.getKey(),
                                                       makeVersioned(entry.getValue())));
    }

    private CompletableFuture<Versioned<V>> makeVersionedFuture(V value) {
        return CompletableFuture.completedFuture(makeVersioned(value));
    }

    private Versioned<V> makeVersioned(V value) {
        return new Versioned<>(value, 1);
    }

    @Override
    public CompletableFuture<String> firstKey() {
        return CompletableFuture.completedFuture(map.firstKey());
    }

    @Override
    public CompletableFuture<String> lastKey() {
        return CompletableFuture.completedFuture(map.lastKey());
    }

    @Override
    public CompletableFuture<Map.Entry<String, Versioned<V>>> ceilingEntry(String key) {
        return makeVersionedEntry(map.ceilingEntry(key));
    }

    @Override
    public CompletableFuture<Map.Entry<String, Versioned<V>>> floorEntry(String key) {
        return makeVersionedEntry(map.floorEntry(key));
    }

    @Override
    public CompletableFuture<Map.Entry<String, Versioned<V>>> higherEntry(String key) {
        return makeVersionedEntry(map.higherEntry(key));
    }

    @Override
    public CompletableFuture<Map.Entry<String, Versioned<V>>> lowerEntry(String key) {
        return makeVersionedEntry(map.lowerEntry(key));
    }

    @Override
    public CompletableFuture<Map.Entry<String, Versioned<V>>> firstEntry() {
        return makeVersionedEntry(map.firstEntry());
    }

    @Override
    public CompletableFuture<Map.Entry<String, Versioned<V>>> lastEntry() {
        return makeVersionedEntry(map.lastEntry());
    }

    @Override
    public CompletableFuture<Map.Entry<String, Versioned<V>>> pollFirstEntry() {
        return makeVersionedEntry(map.pollFirstEntry());
    }

    @Override
    public CompletableFuture<Map.Entry<String, Versioned<V>>> pollLastEntry() {
        return makeVersionedEntry(map.pollLastEntry());
    }

    @Override
    public CompletableFuture<String> lowerKey(String key) {
        return CompletableFuture.completedFuture(map.lowerKey(key));
    }

    @Override
    public CompletableFuture<String> floorKey(String key) {
        return CompletableFuture.completedFuture(map.floorKey(key));
    }

    @Override
    public CompletableFuture<String> ceilingKey(String key) {
        return CompletableFuture.completedFuture(map.ceilingKey(key));
    }

    @Override
    public CompletableFuture<String> higherKey(String key) {
        return CompletableFuture.completedFuture(map.higherKey(key));
    }

    @Override
    public CompletableFuture<NavigableSet<String>> navigableKeySet() {
        return CompletableFuture.completedFuture(map.navigableKeySet());
    }

    @Override
    public CompletableFuture<NavigableMap<String, V>> subMap(String upperKey, String lowerKey,
                                                             boolean inclusiveUpper, boolean inclusiveLower) {
        NavigableMap<String, V> subMap = map.subMap(upperKey, inclusiveLower, lowerKey, inclusiveLower);
        return CompletableFuture.completedFuture(subMap);
    }

    @Override
    public ConsistentTreeMap<V> asTreeMap() {
        return null;
    }

    @Override
    public ConsistentTreeMap<V> asTreeMap(long timeoutMillis) {
        return null;
    }

    @Override
    public Type primitiveType() {
        return null;
    }

    @Override
    public CompletableFuture<Integer> size() {
        return CompletableFuture.completedFuture(map.size());
    }

    @Override
    public CompletableFuture<Boolean> isEmpty() {
        return CompletableFuture.completedFuture(map.isEmpty());
    }

    @Override
    public CompletableFuture<Boolean> containsKey(String key) {
        return CompletableFuture.completedFuture(map.containsKey(key));
    }

    @Override
    public CompletableFuture<Boolean> containsValue(V value) {
        return CompletableFuture.completedFuture(map.containsValue(value));
    }

    @Override
    public CompletableFuture<Versioned<V>> get(String key) {
        return makeVersionedFuture(map.get(key));
    }

    @Override
    public CompletableFuture<Versioned<V>> getOrDefault(String key, V defaultValue) {
        return makeVersionedFuture(map.getOrDefault(key, defaultValue));
    }

    @Override
    public CompletableFuture<Versioned<V>>
           computeIfAbsent(String key, Function<? super String, ? extends V> mappingFunction) {
        return makeVersionedFuture(map.computeIfAbsent(key, mappingFunction));
    }

    @Override
    public CompletableFuture<Versioned<V>>
           computeIfPresent(String key, BiFunction<? super String, ? super V, ? extends V> remappingFunction) {
        return makeVersionedFuture(map.computeIfPresent(key, remappingFunction));
    }

    @Override
    public CompletableFuture<Versioned<V>>
           compute(String key, BiFunction<? super String, ? super V, ? extends V> remappingFunction) {
        return makeVersionedFuture(map.compute(key, remappingFunction));
    }

    @Override
    public CompletableFuture<Versioned<V>>
    computeIf(String key, Predicate<? super V> condition,
              BiFunction<? super String, ? super V, ? extends V> remappingFunction) {

        V value = map.get(key);

        if (condition.test(value)) {
            value = map.compute(key, remappingFunction);
        }
        return makeVersionedFuture(value);
    }

    @Override
    public CompletableFuture<Versioned<V>> put(String key, V value) {
        return makeVersionedFuture(map.put(key, value));
    }

    @Override
    public CompletableFuture<Versioned<V>> putAndGet(String key, V value) {
        return makeVersionedFuture(map.put(key, value));
    }

    @Override
    public CompletableFuture<Versioned<V>> remove(String key) {
        return makeVersionedFuture(map.remove(key));
    }

    @Override
    public CompletableFuture<Void> clear() {
        map.clear();
        return CompletableFuture.completedFuture(null);
    }

    @Override
    public CompletableFuture<Set<String>> keySet() {
        return CompletableFuture.completedFuture(map.keySet());
    }

    @Override
    public CompletableFuture<Collection<Versioned<V>>> values() {
        Set<Versioned<V>> valuesAsVersionedCollection =
                map.values().stream().map(this::makeVersioned)
                        .collect(Collectors.toSet());
        return CompletableFuture.completedFuture(valuesAsVersionedCollection);
    }

    @Override
    public CompletableFuture<Set<Map.Entry<String, Versioned<V>>>> entrySet() {
        Map<String, Versioned<V>> valuesAsVersionedMap = new HashMap<>();
        map.forEach((key, value) ->
                valuesAsVersionedMap.put(key, makeVersioned(value))
        );
        return CompletableFuture.completedFuture(valuesAsVersionedMap.entrySet());
    }

    @Override
    public CompletableFuture<Versioned<V>> putIfAbsent(String key, V value) {
        return makeVersionedFuture(map.putIfAbsent(key, value));
    }

    @Override
    public CompletableFuture<Boolean> remove(String key, V value) {
        return CompletableFuture.completedFuture(map.remove(key, value));
    }

    @Override
    public CompletableFuture<Boolean> remove(String key, long version) {
        Object value = map.remove(key);
        return CompletableFuture.completedFuture(value != null);
    }

    @Override
    public CompletableFuture<Versioned<V>> replace(String key, V value) {
        return makeVersionedFuture(map.replace(key, value));
    }

    @Override
    public CompletableFuture<Boolean> replace(String key, V oldValue, V newValue) {
        return CompletableFuture.completedFuture(map.replace(key, oldValue, newValue));
    }

    @Override
    public CompletableFuture<Boolean> replace(String key, long oldVersion, V newValue) {
        map.replace(key, newValue);
        return CompletableFuture.completedFuture(true);
    }

    @Override
    public CompletableFuture<Void> addListener(MapEventListener<String, V> listener) {
        return null;
    }

    @Override
    public CompletableFuture<Void> addListener(MapEventListener<String, V> listener, Executor executor) {
        return null;
    }

    @Override
    public CompletableFuture<Void> removeListener(MapEventListener<String, V> listener) {
        return null;
    }

    @Override
    public ConsistentMap<String, V> asConsistentMap() {
        return null;
    }

    @Override
    public ConsistentMap<String, V> asConsistentMap(long timeoutMillis) {
        return null;
    }

    @Override
    public String name() {
        return null;
    }

    @Override
    public ApplicationId applicationId() {
        return null;
    }

    @Override
    public void addStatusChangeListener(Consumer<Status> listener) {

    }

    @Override
    public void removeStatusChangeListener(Consumer<Status> listener) {

    }

    @Override
    public Collection<Consumer<Status>> statusChangeListeners() {
        return null;
    }

    @Override
    public CompletableFuture<Version> begin(TransactionId transactionId) {
        return null;
    }

    @Override
    public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<String, V>> transactionLog) {
        return null;
    }

    @Override
    public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<String, V>> transactionLog) {
        return null;
    }

    @Override
    public CompletableFuture<Void> commit(TransactionId transactionId) {
        return null;
    }

    @Override
    public CompletableFuture<Void> rollback(TransactionId transactionId) {
        return null;
    }

    @Override
    public CompletableFuture<AsyncIterator<Map.Entry<String, Versioned<V>>>> iterator() {
        return null;
    }
}