com.hazelcast.cache.impl.AbstractClusterWideIterator Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2008-2016, Hazelcast, Inc. All Rights Reserved.
 *
 * 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 com.hazelcast.cache.impl;

import com.hazelcast.cache.ICache;
import com.hazelcast.nio.serialization.Data;

import javax.cache.Cache;
import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * {@link AbstractClusterWideIterator} provides the core iterator functionality shared by its descendants.
 *
 *Hazelcast cluster is made of partitions which holds a slice of all clusters data. Partition count
 * never increase or decrease in a cluster. In order to implement an iterator over a partitioned data, we use
 * the following parameters.
 *

 *To iterate over partitioned data, we use partitionId as the first parameter of this iterator.
 *Each partition may have a lot of entries, so we use a second parameter to track the iteration of the
 * partition.
 *
 *
 * 
 *Iteration steps:
 * 

 *     fetching fixed sized of keys from the current partition defined by partitionId.
 *     iteration on fetched keys.
 *     get value of each key with {@link #next()} when method is called.
 *     when fetched keys are all used by calling {@link #next()}, more keys are fetched from the cluster.
 * 
 * This implementation iterates over partitions and for each partition it iterates over the internal map using the
 *     internal table index of the map {@link com.hazelcast.util.SampleableConcurrentHashMap}.
 * 
 * 
 * 
Fetching data from cluster:
 * Fetching is getting a fixed size of keys from the internal table of records of a partition defined by
 * partitionId. Table index is also provided as a table index locator. Fetch response is the keys and
 * last table index. The last table index is included in the result to be used in the next fetch.
 * 
 * 
 * 
Notes:
 * 
 * Iterator fetches keys in batch with a fixed size that is configurable.
 * Fetched keys are cached in the iterator to be used in each iteration step.
 * {@link #hasNext()} may return true for a key already removed.
 * {@link #hasNext()} only return false when all known keys are fetched and iterated.
 * {@link #next()} may return null although cache never has null value. This may happen when, for example,
 * someone removes the entry after the current thread has checked with {@link #hasNext()}.
 * This implementation does not affected by value updates as each value is got from the cluster
 * when {@link #next()} called.
 * 
 * 
 *
 * @param  the type of key.
 * @param  the type of value.
 * @see com.hazelcast.cache.impl.CacheRecordStore#iterator(int tableIndex, int size)
 * @see com.hazelcast.cache.impl.ClusterWideIterator
 * @see com.hazelcast.cache.impl.CacheKeyIteratorResult
 */
public abstract class AbstractClusterWideIterator
        implements Iterator> {

    private static final int FETCH_SIZE = 100;

    protected ICache cache;

    protected CacheKeyIteratorResult result;
    protected final int partitionCount;
    protected int partitionIndex = -1;

    protected int lastTableIndex;

    protected final int fetchSize;

    protected int index;
    protected int currentIndex = -1;

    public AbstractClusterWideIterator(ICache cache, int partitionCount) {
        this.cache = cache;
        this.partitionCount = partitionCount;

        //TODO can be made configurable
        this.fetchSize = FETCH_SIZE;
    }

    @Override
    public boolean hasNext() {
        ensureOpen();
        if (result != null && index < result.getCount()) {
            return true;
        }
        return advance();
    }

    @Override
    public Cache.Entry next() {
        while (hasNext()) {
            currentIndex = index;
            index++;
            final Data keyData = result.getKey(currentIndex);
            final K key = toObject(keyData);
            final V value = cache.get(key);
            // Value might be removed or evicted
            if (value != null) {
                return new CacheEntry(key, value);
            }
        }
        throw new NoSuchElementException();
    }

    @Override
    public void remove() {
        ensureOpen();
        if (result == null || currentIndex < 0) {
            throw new IllegalStateException("Iterator.next() must be called before remove()!");
        }
        Data keyData = result.getKey(currentIndex);
        final K key = toObject(keyData);
        cache.remove(key);
        currentIndex = -1;
    }

    protected boolean advance() {
        while (partitionIndex < getPartitionCount()) {
            if (result == null || result.getCount() < fetchSize || lastTableIndex < 0) {
                partitionIndex++;
                lastTableIndex = Integer.MAX_VALUE;
                result = null;
                if (partitionIndex == getPartitionCount()) {
                    return false;
                }
            }
            result = fetch();
            if (result != null && result.getCount() > 0) {
                index = 0;
                lastTableIndex = result.getTableIndex();
                return true;
            }
        }
        return false;
    }

    protected void ensureOpen() {
        if (cache.isClosed()) {
            throw new IllegalStateException("Cache operations can not be performed. The cache closed");
        }
    }

    protected int getPartitionCount() {
        return partitionCount;
    }

    protected abstract CacheKeyIteratorResult fetch();

    protected abstract Data toData(Object obj);

    protected abstract  T toObject(Object data);
}