How to use com.hazelcast.map.impl.operation

@Override
public void run() {
  mapReplicationStateHolder.applyState();
  writeBehindStateHolder.applyState();
  if (getReplicaIndex() == 0) {
    mapNearCacheStateHolder.applyState();
  }
}

@Override
protected void writeInternal(final ObjectDataOutput out) throws IOException {
  mapReplicationStateHolder.writeData(out);
  writeBehindStateHolder.writeData(out);
  mapNearCacheStateHolder.writeData(out);
}

@Override
protected void readInternal(final ObjectDataInput in) throws IOException {
  mapReplicationStateHolder.readData(in);
  writeBehindStateHolder.readData(in);
  mapNearCacheStateHolder.readData(in);
}

@Override
public void run() throws Exception {
  EntryOperator operator = operator(this, backupProcessor, getPredicate());
  for (Data key : keys) {
    operator.operateOnKey(key).doPostOperateOps();
  }
}

@Override
public void sendResponse(Operation op, Object response) {
  if (isRetryable(response) || isTimeout(response)) {
    retry(op);
  } else {
    EntryOperation.this.sendResponse(toResponse(response));
  }
}

@Override
public MapOperation createSetOperation(String name, Data dataKey, Data value, long ttl, long maxIdle) {
  checkWanReplicationQueues(name);
  return getDelegate().createSetOperation(name, dataKey, value, ttl, maxIdle);
}

@Override
public MapOperation createPutIfAbsentOperation(String name, Data key, Data value, long ttl, long maxIdle) {
  checkWanReplicationQueues(name);
  return getDelegate().createPutIfAbsentOperation(name, key, value, ttl, maxIdle);
}

@Override
public MapOperation createPutTransientOperation(String name, Data key, Data value, long ttl, long maxIdle) {
  checkWanReplicationQueues(name);
  return getDelegate().createPutTransientOperation(name, key, value, ttl, maxIdle);
}

@Override
public OperationFactory createPutAllOperationFactory(String name, int[] partitions, MapEntries[] mapEntries) {
  checkWanReplicationQueues(name);
  return getDelegate().createPutAllOperationFactory(name, partitions, mapEntries);
}

@Override
public MapOperation createPutFromLoadAllOperation(String name, List<Data> keyValueSequence) {
  checkWanReplicationQueues(name);
  return getDelegate().createPutFromLoadAllOperation(name, keyValueSequence);
}

@Override
public MapOperation createTxnSetOperation(String name, Data dataKey, Data value, long version, long ttl) {
  checkWanReplicationQueues(name);
  return getDelegate().createTxnSetOperation(name, dataKey, value, version, ttl);
}

@Override
public OperationFactory createPartitionWideEntryOperationFactory(String name, EntryProcessor entryProcessor) {
  checkWanReplicationQueues(name);
  return getDelegate().createPartitionWideEntryOperationFactory(name, entryProcessor);
}

private void publishWanReplicationEvent() {
  assert entryWasModified();
  if (eventType == REMOVED) {
    mapOperation.publishWanRemove(dataKey);
  } else {
    mapOperation.publishWanUpdate(dataKey, newValue);
  }
}

@Override
public OperationFactory createPartitionWideEntryWithPredicateOperationFactory(String name,
                                       EntryProcessor entryProcessor,
                                       Predicate predicate) {
  checkWanReplicationQueues(name);
  return getDelegate().createPartitionWideEntryWithPredicateOperationFactory(name, entryProcessor, predicate);
}

@Override
public void afterRun() throws Exception {
  invalidateNearCache(invalidationKeys);
  super.afterRun();
}

@Override
public OperationFactory createMergeOperationFactory(String name, int[] partitions, List<MapMergeTypes>[] mergingEntries,
                          SplitBrainMergePolicy<Data, MapMergeTypes> mergePolicy) {
  return getDelegate().createMergeOperationFactory(name, partitions, mergingEntries, mergePolicy);
}

@Override
public MapOperation createTxnLockAndGetOperation(String name, Data dataKey, long timeout,
                         long ttl, String ownerUuid, boolean shouldLoad, boolean blockReads) {
  return getDelegate().createTxnLockAndGetOperation(name, dataKey, timeout, ttl, ownerUuid, shouldLoad, blockReads);
}

@Override
public void afterRun() throws Exception {
  super.afterRun();
  invalidateNearCache(keys);
}

@Override
public MapOperation createMergeOperation(String name, MapMergeTypes mergingValue,
                     SplitBrainMergePolicy<Data, MapMergeTypes> mergePolicy,
                     boolean disableWanReplicationEvent) {
  return getDelegate().createMergeOperation(name, mergingValue, mergePolicy, disableWanReplicationEvent);
}

@Override
protected void readInternal(final ObjectDataInput in) throws IOException {
  mapReplicationStateHolder.readData(in);
  writeBehindStateHolder.readData(in);
  mapNearCacheStateHolder.readData(in);
}