    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      https://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017package org.apache.commons.collections4.bloomfilter;
    018
    019import java.util.function.IntPredicate;
    020import java.util.function.LongPredicate;
    021
    022/**
    023 * An abstract class to assist in implementing Bloom filter decorators.
    024 *
    025 * @param <T> The WrappedBloomFilter type.
    026 * @param <W> The <em>wrapped</em> BloomFilter type.
    027 * @since 4.5.0-M1
    028 */
    029public abstract class WrappedBloomFilter<T extends WrappedBloomFilter<T, W>, W extends BloomFilter<W>> implements BloomFilter<T> {
    030
    031    private final W wrapped;
    032
    033    /**
    034     * Wraps a Bloom filter.  The wrapped filter is maintained as a reference
    035     * not a copy.  Changes in one will be reflected in the other.
    036     *
    037     * @param wrapped The Bloom filter.
    038     */
    039    public WrappedBloomFilter(final W wrapped) {
    040        this.wrapped = wrapped;
    041    }
    042
    043    @Override
    044    public long[] asBitMapArray() {
    045        return wrapped.asBitMapArray();
    046    }
    047
    048    @Override
    049    public int[] asIndexArray() {
    050        return wrapped.asIndexArray();
    051    }
    052
    053    @Override
    054    public int cardinality() {
    055        return wrapped.cardinality();
    056    }
    057
    058    @Override
    059    public int characteristics() {
    060        return wrapped.characteristics();
    061    }
    062
    063    @Override
    064    public void clear() {
    065        wrapped.clear();
    066    }
    067
    068    @Override
    069    public boolean contains(final BitMapExtractor bitMapExtractor) {
    070        return wrapped.contains(bitMapExtractor);
    071    }
    072
    073    @Override
    074    public boolean contains(final BloomFilter<?> other) {
    075        return wrapped.contains(other);
    076    }
    077
    078    @Override
    079    public boolean contains(final Hasher hasher) {
    080        return wrapped.contains(hasher);
    081    }
    082
    083    @Override
    084    public boolean contains(final IndexExtractor indexExtractor) {
    085        return wrapped.contains(indexExtractor);
    086    }
    087
    088    @Override
    089    public int estimateIntersection(final BloomFilter<?> other) {
    090        return wrapped.estimateIntersection(other);
    091    }
    092
    093    @Override
    094    public int estimateN() {
    095        return wrapped.estimateN();
    096    }
    097
    098    @Override
    099    public int estimateUnion(final BloomFilter<?> other) {
    100        return wrapped.estimateUnion(other);
    101    }
    102
    103    @Override
    104    public Shape getShape() {
    105        return wrapped.getShape();
    106    }
    107
    108    /**
    109     * Gets the wrapped BloomFilter.
    110     *
    111     * @return The wrapped BloomFilter.
    112     */
    113    protected W getWrapped() {
    114        return wrapped;
    115    }
    116
    117    @Override
    118    public boolean isFull() {
    119        return wrapped.isFull();
    120    }
    121
    122    @Override
    123    public boolean merge(final BitMapExtractor bitMapExtractor) {
    124        return wrapped.merge(bitMapExtractor);
    125    }
    126
    127    @Override
    128    public boolean merge(final BloomFilter<?> other) {
    129        return wrapped.merge(other);
    130    }
    131
    132    @Override
    133    public boolean merge(final Hasher hasher) {
    134        return wrapped.merge(hasher);
    135    }
    136
    137    @Override
    138    public boolean merge(final IndexExtractor indexExtractor) {
    139        return wrapped.merge(indexExtractor);
    140    }
    141
    142    @Override
    143    public boolean processBitMapPairs(final BitMapExtractor other, final LongBiPredicate func) {
    144        return wrapped.processBitMapPairs(other, func);
    145    }
    146
    147    @Override
    148    public boolean processBitMaps(final LongPredicate predicate) {
    149        return wrapped.processBitMaps(predicate);
    150    }
    151
    152    @Override
    153    public boolean processIndices(final IntPredicate predicate) {
    154        return wrapped.processIndices(predicate);
    155    }
    156}