Examples with MapEntries com.hazelcast.map.impl.MapEntries used on opensource projects

Example 11 with MapEntries

use of com.hazelcast.map.impl.MapEntries in project hazelcast by hazelcast.

the class PutAllPartitionAwareOperationFactory method readData.

@Override
public void readData(ObjectDataInput in) throws IOException {
    name = in.readUTF();
    partitions = in.readIntArray();
    mapEntries = new MapEntries[partitions.length];
    for (int i = 0; i < partitions.length; i++) {
        MapEntries entry = new MapEntries();
        entry.readData(in);
        mapEntries[i] = entry;
    }
}

Example 12 with MapEntries

use of com.hazelcast.map.impl.MapEntries in project hazelcast by hazelcast.

the class MultipleEntryOperation method run.

@Override
@SuppressWarnings("checkstyle:npathcomplexity")
public void run() throws Exception {
    long now = getNow();
    boolean shouldClone = mapContainer.shouldCloneOnEntryProcessing();
    SerializationService serializationService = getNodeEngine().getSerializationService();
    responses = new MapEntries(keys.size());
    for (Data key : keys) {
        if (!isKeyProcessable(key)) {
            continue;
        }
        Object oldValue = recordStore.get(key, false);
        Object value = shouldClone ? serializationService.toObject(serializationService.toData(oldValue)) : oldValue;
        Map.Entry entry = createMapEntry(key, value);
        if (!isEntryProcessable(entry)) {
            continue;
        }
        Data response = process(entry);
        if (response != null) {
            responses.add(key, response);
        }
        // first call noOp, other if checks below depends on it.
        if (noOp(entry, oldValue, now)) {
            continue;
        }
        if (entryRemoved(entry, key, oldValue, now)) {
            continue;
        }
        entryAddedOrUpdated(entry, key, oldValue, now);
        evict(key);
    }
}

Example 13 with MapEntries

use of com.hazelcast.map.impl.MapEntries in project hazelcast by hazelcast.

the class MapProxySupport method executeOnKeysInternal.

public Map executeOnKeysInternal(Set<Data> keys, EntryProcessor entryProcessor) {
    // TODO: why are we not forwarding to executeOnKeysInternal(keys, entryProcessor, null) or some other kind of fake
    // callback? now there is a lot of code duplication
    Map<Object, Object> result = new HashMap<Object, Object>();
    Collection<Integer> partitionsForKeys = getPartitionsForKeys(keys);
    try {
        OperationFactory operationFactory = operationProvider.createMultipleEntryOperationFactory(name, keys, entryProcessor);
        Map<Integer, Object> results = operationService.invokeOnPartitions(SERVICE_NAME, operationFactory, partitionsForKeys);
        for (Object object : results.values()) {
            if (object != null) {
                MapEntries mapEntries = (MapEntries) object;
                mapEntries.putAllToMap(serializationService, result);
            }
        }
    } catch (Throwable t) {
        throw rethrow(t);
    }
    return result;
}

Example 14 with MapEntries

use of com.hazelcast.map.impl.MapEntries in project hazelcast by hazelcast.

the class MapPutAllWrongTargetForPartitionTest method createPutAllOperationFactory.

private PartitionAwareOperationFactory createPutAllOperationFactory(int entriesPerPartition, String mapName, HazelcastInstance hz, SerializationService serializationService) {
    int[] partitions = new int[INSTANCE_COUNT];
    MapEntries[] entries = new MapEntries[INSTANCE_COUNT];
    for (int partitionId = 0; partitionId < INSTANCE_COUNT; partitionId++) {
        MapEntries mapEntries = new MapEntries(entriesPerPartition);
        for (int i = 0; i < entriesPerPartition; i++) {
            String key = generateKeyForPartition(hz, partitionId);
            Data data = serializationService.toData(key);
            mapEntries.add(data, data);
        }
        partitions[partitionId] = partitionId;
        entries[partitionId] = mapEntries;
    }
    return getPutAllPartitionAwareOperationFactory(mapName, partitions, entries);
}

Example 15 with MapEntries

use of com.hazelcast.map.impl.MapEntries in project hazelcast by hazelcast.

the class MapProxySupport method putAllInternal.

/**
     * This method will group all puts per partition and send a
     * {@link com.hazelcast.map.impl.operation.PutAllPartitionAwareOperationFactory} per member.
     * <p/>
     * If there are e.g. five keys for a single member, there will only be a single remote invocation
     * instead of having five remote invocations.
     * <p/>
     * There is also an optional support for batching to send smaller packages.
     * Takes care about {@code null} checks for keys and values.
     */
@SuppressWarnings({ "checkstyle:npathcomplexity", "UnnecessaryBoxing" })
@SuppressFBWarnings(value = "DM_NUMBER_CTOR", justification = "we need a shared counter object for each member per partition")
protected void putAllInternal(Map<?, ?> map) {
    try {
        int mapSize = map.size();
        if (mapSize == 0) {
            return;
        }
        boolean useBatching = isPutAllUseBatching(mapSize);
        int partitionCount = partitionService.getPartitionCount();
        int initialSize = getPutAllInitialSize(useBatching, mapSize, partitionCount);
        Map<Address, List<Integer>> memberPartitionsMap = partitionService.getMemberPartitionsMap();
        // init counters for batching
        MutableLong[] counterPerMember = null;
        Address[] addresses = null;
        if (useBatching) {
            counterPerMember = new MutableLong[partitionCount];
            addresses = new Address[partitionCount];
            for (Entry<Address, List<Integer>> addressListEntry : memberPartitionsMap.entrySet()) {
                MutableLong counter = new MutableLong();
                Address address = addressListEntry.getKey();
                for (int partitionId : addressListEntry.getValue()) {
                    counterPerMember[partitionId] = counter;
                    addresses[partitionId] = address;
                }
            }
        }
        // fill entriesPerPartition
        MapEntries[] entriesPerPartition = new MapEntries[partitionCount];
        for (Entry entry : map.entrySet()) {
            checkNotNull(entry.getKey(), NULL_KEY_IS_NOT_ALLOWED);
            checkNotNull(entry.getValue(), NULL_VALUE_IS_NOT_ALLOWED);
            Data keyData = toData(entry.getKey(), partitionStrategy);
            int partitionId = partitionService.getPartitionId(keyData);
            MapEntries entries = entriesPerPartition[partitionId];
            if (entries == null) {
                entries = new MapEntries(initialSize);
                entriesPerPartition[partitionId] = entries;
            }
            entries.add(keyData, toData(entry.getValue()));
            if (useBatching) {
                long currentSize = ++counterPerMember[partitionId].value;
                if (currentSize % putAllBatchSize == 0) {
                    List<Integer> partitions = memberPartitionsMap.get(addresses[partitionId]);
                    invokePutAllOperation(addresses[partitionId], partitions, entriesPerPartition);
                }
            }
        }
        // invoke operations for entriesPerPartition
        for (Entry<Address, List<Integer>> entry : memberPartitionsMap.entrySet()) {
            invokePutAllOperation(entry.getKey(), entry.getValue(), entriesPerPartition);
        }
    } catch (Exception e) {
        throw rethrow(e);
    }
}