io.horizon.util.CZip Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of vertx-ams Show documentation
The newest version!
package io.horizon.util;

import io.horizon.eon.VValue;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.BiFunction;
import java.util.function.Function;

/**
 * @author lang : 2023/4/30
 */
class CZip {

    static  ConcurrentMap zip(final Collection object, final Function keyFn, final Function valueFn) {
        final ConcurrentMap ret = new ConcurrentHashMap<>();
        if (0 < object.size()) {
            for (final E item : object) {
                if (null != item) {
                    final K key = keyFn.apply(item);
                    final V value = valueFn.apply(item);
                    if (null != key && null != value) {
                        ret.put(key, value);
                    }
                }
            }
        }
        return ret;
    }

    static  ConcurrentMap zip(final ConcurrentMap source, final ConcurrentMap target) {
        final ConcurrentMap resultMap = new ConcurrentHashMap<>();
        if (Objects.nonNull(source) && Objects.nonNull(target)) {
            source.forEach((k, t) -> {
                final V value = target.get(t);
                if (Objects.nonNull(value)) {
                    resultMap.put(k, value);
                }
            });
        }
        return resultMap;
    }
    
    static  ConcurrentMap zip(final Set from, final ConcurrentMap to) {
        final ConcurrentMap result = new ConcurrentHashMap<>();
        from.forEach((key) -> {
            final V value = to.get(key);
            if (null != value) {
                result.put(key, value);
            }
        });
        return result;
    }

    static  List zip(final List first, final List second, final BiFunction function) {
        final List result = new ArrayList<>();
        final int length = first.size();
        for (int idx = VValue.IDX; idx < length; idx++) {
            final F key = first.get(idx);
            final S value = valueSure(second, idx);
            final T combine = function.apply(key, value);
            if (null != key && null != combine) {
                result.add(combine);
            }
        }
        return result;
    }

    static  ConcurrentMap zip(final List keys, final List values) {
        final ConcurrentMap result = new ConcurrentHashMap<>();
        final int length = keys.size();
        for (int idx = VValue.IDX; idx < length; idx++) {
            final F key = keys.get(idx);
            final T value = valueSure(values, idx);
            if (null != key && null != value) {
                result.put(key, value);
            }
        }
        return result;
    }

    private static  T valueSure(final List list, final int index) {
        return (0 <= index) && (index < list.size()) ? list.get(index) : null;
    }
}