Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (c) 2008-2021, 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.multimap.impl;
import com.hazelcast.internal.locksupport.LockStore;
import com.hazelcast.internal.locksupport.LockSupportService;
import com.hazelcast.internal.serialization.Data;
import com.hazelcast.internal.serialization.SerializationService;
import com.hazelcast.internal.services.DistributedObjectNamespace;
import com.hazelcast.internal.services.ObjectNamespace;
import com.hazelcast.spi.merge.SplitBrainMergePolicy;
import com.hazelcast.spi.merge.SplitBrainMergeTypes.MultiMapMergeTypes;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import static com.hazelcast.internal.util.Clock.currentTimeMillis;
import static com.hazelcast.internal.util.MapUtil.createHashMap;
import static com.hazelcast.spi.impl.merge.MergingValueFactory.createMergingEntry;
/**
* MultiMap container which holds a map of {@link MultiMapValue}.
*/
@SuppressWarnings("checkstyle:methodcount")
public class MultiMapContainer extends MultiMapContainerSupport {
private static final int ID_PROMOTION_OFFSET = 100000;
private final DistributedObjectNamespace lockNamespace;
private final LockStore lockStore;
private final int partitionId;
private final long creationTime;
private final ObjectNamespace objectNamespace;
private long idGen;
// these fields are volatile since they can be read by other threads than the partition-thread
private volatile long lastAccessTime;
private volatile long lastUpdateTime;
public MultiMapContainer(String name, MultiMapService service, int partitionId) {
super(name, service.getNodeEngine());
this.partitionId = partitionId;
this.lockNamespace = new DistributedObjectNamespace(MultiMapService.SERVICE_NAME, name);
LockSupportService lockService = nodeEngine.getServiceOrNull(LockSupportService.SERVICE_NAME);
this.lockStore = lockService == null ? null : lockService.createLockStore(partitionId, lockNamespace);
this.creationTime = currentTimeMillis();
this.objectNamespace = new DistributedObjectNamespace(MultiMapService.SERVICE_NAME, name);
}
public boolean canAcquireLock(Data dataKey, UUID caller, long threadId) {
return lockStore != null && lockStore.canAcquireLock(dataKey, caller, threadId);
}
public boolean isLocked(Data dataKey) {
return lockStore != null && lockStore.isLocked(dataKey);
}
public boolean isTransactionallyLocked(Data key) {
return lockStore != null && lockStore.shouldBlockReads(key);
}
public boolean txnLock(Data key, UUID caller, long threadId, long referenceId, long ttl, boolean blockReads) {
return lockStore != null && lockStore.txnLock(key, caller, threadId, referenceId, ttl, blockReads);
}
public boolean unlock(Data key, UUID caller, long threadId, long referenceId) {
return lockStore != null && lockStore.unlock(key, caller, threadId, referenceId);
}
public boolean forceUnlock(Data key) {
return lockStore != null && lockStore.forceUnlock(key);
}
public boolean extendLock(Data key, UUID caller, long threadId, long ttl) {
return lockStore != null && lockStore.extendLeaseTime(key, caller, threadId, ttl);
}
public String getLockOwnerInfo(Data dataKey) {
return lockStore != null ? lockStore.getOwnerInfo(dataKey) : null;
}
public long nextId() {
return idGen++;
}
public void setId(long newValue) {
idGen = newValue + ID_PROMOTION_OFFSET;
}
public boolean delete(Data dataKey) {
return multiMapValues.remove(dataKey) != null;
}
public Collection remove(Data dataKey, boolean copyOf) {
MultiMapValue multiMapValue = multiMapValues.remove(dataKey);
return multiMapValue != null ? multiMapValue.getCollection(copyOf) : null;
}
public Set keySet() {
Set keySet = multiMapValues.keySet();
return new HashSet<>(keySet);
}
public Collection values() {
Collection valueCollection = new LinkedList<>();
for (MultiMapValue multiMapValue : multiMapValues.values()) {
valueCollection.addAll(multiMapValue.getCollection(false));
}
return valueCollection;
}
public boolean containsKey(Data key) {
return multiMapValues.containsKey(key);
}
public boolean containsEntry(boolean binary, Data key, Data value) {
MultiMapValue multiMapValue = multiMapValues.get(key);
if (multiMapValue == null) {
return false;
}
MultiMapRecord record = new MultiMapRecord(binary ? value : nodeEngine.toObject(value));
return multiMapValue.getCollection(false).contains(record);
}
public boolean containsValue(boolean binary, Data value) {
for (Data key : multiMapValues.keySet()) {
if (containsEntry(binary, key, value)) {
return true;
}
}
return false;
}
public Map> copyCollections() {
Map> map = createHashMap(multiMapValues.size());
for (Map.Entry entry : multiMapValues.entrySet()) {
Data key = entry.getKey();
Collection col = entry.getValue().getCollection(true);
map.put(key, col);
}
return map;
}
public int size() {
int size = 0;
for (MultiMapValue multiMapValue : multiMapValues.values()) {
size += multiMapValue.getCollection(false).size();
}
return size;
}
public int clear() {
Collection locks = lockStore != null ? lockStore.getLockedKeys() : Collections.emptySet();
Map lockedKeys = createHashMap(locks.size());
for (Data key : locks) {
MultiMapValue multiMapValue = multiMapValues.get(key);
if (multiMapValue != null) {
lockedKeys.put(key, multiMapValue);
}
}
int numberOfAffectedEntries = multiMapValues.size() - lockedKeys.size();
multiMapValues.clear();
multiMapValues.putAll(lockedKeys);
return numberOfAffectedEntries;
}
public void destroy() {
LockSupportService lockService = nodeEngine.getServiceOrNull(LockSupportService.SERVICE_NAME);
if (lockService != null) {
lockService.clearLockStore(partitionId, lockNamespace);
}
multiMapValues.clear();
}
public void access() {
lastAccessTime = currentTimeMillis();
}
public void update() {
lastUpdateTime = currentTimeMillis();
}
public long getLastAccessTime() {
return lastAccessTime;
}
public long getLastUpdateTime() {
return lastUpdateTime;
}
public long getCreationTime() {
return creationTime;
}
public long getLockedCount() {
return lockStore.getLockedKeys().size();
}
public ObjectNamespace getObjectNamespace() {
return objectNamespace;
}
public int getPartitionId() {
return partitionId;
}
/**
* Merges the given {@link MultiMapMergeContainer} via the given {@link SplitBrainMergePolicy}.
*
* @param mergeContainer the {@link MultiMapMergeContainer} instance to merge
* @param mergePolicy the {@link SplitBrainMergePolicy} instance to apply
* @return the used {@link MultiMapValue} if merge is applied, otherwise {@code null}
*/
public MultiMapValue merge(MultiMapMergeContainer mergeContainer,
SplitBrainMergePolicy, MultiMapMergeTypes,
Collection
