Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 49F70200C6F for ; Tue, 9 May 2017 23:09:01 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id 489E2160BC8; Tue, 9 May 2017 21:09:01 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 7A881160BE9 for ; Tue, 9 May 2017 23:08:54 +0200 (CEST) Received: (qmail 55143 invoked by uid 500); 9 May 2017 21:08:52 -0000 Mailing-List: contact commits-help@geode.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@geode.apache.org Delivered-To: mailing list commits@geode.apache.org Received: (qmail 53648 invoked by uid 99); 9 May 2017 21:08:50 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 09 May 2017 21:08:50 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 3127FEE68D; Tue, 9 May 2017 21:08:50 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: klund@apache.org To: commits@geode.apache.org Date: Tue, 09 May 2017 21:09:23 -0000 Message-Id: <0213855d49a34d8b97b332cc52757b15@git.apache.org> In-Reply-To: <34454995741e4bdd9af5440ac3a581b8@git.apache.org> References: <34454995741e4bdd9af5440ac3a581b8@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [35/50] geode git commit: GEODE-2632: change dependencies on GemFireCacheImpl to InternalCache archived-at: Tue, 09 May 2017 21:09:01 -0000 http://git-wip-us.apache.org/repos/asf/geode/blob/d888c75e/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractRegion.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractRegion.java b/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractRegion.java index e0a8f6c..8c10f60 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractRegion.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractRegion.java @@ -12,16 +12,66 @@ * or implied. See the License for the specific language governing permissions and limitations under * the License. */ - package org.apache.geode.internal.cache; +import java.io.DataInput; +import java.io.DataOutput; +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CopyOnWriteArraySet; +import java.util.concurrent.atomic.AtomicLong; + +import org.apache.logging.log4j.Logger; + import org.apache.geode.DataSerializer; -import org.apache.geode.cache.*; -import org.apache.geode.cache.asyncqueue.AsyncEventQueue; +import org.apache.geode.cache.AttributesMutator; +import org.apache.geode.cache.CacheCallback; +import org.apache.geode.cache.CacheListener; +import org.apache.geode.cache.CacheLoader; +import org.apache.geode.cache.CacheLoaderException; +import org.apache.geode.cache.CacheStatistics; +import org.apache.geode.cache.CacheWriter; +import org.apache.geode.cache.CacheWriterException; +import org.apache.geode.cache.CustomExpiry; +import org.apache.geode.cache.DataPolicy; +import org.apache.geode.cache.DiskWriteAttributes; +import org.apache.geode.cache.EntryExistsException; +import org.apache.geode.cache.EntryNotFoundException; +import org.apache.geode.cache.EvictionAttributes; +import org.apache.geode.cache.EvictionAttributesMutator; +import org.apache.geode.cache.ExpirationAction; +import org.apache.geode.cache.ExpirationAttributes; +import org.apache.geode.cache.MembershipAttributes; +import org.apache.geode.cache.MirrorType; +import org.apache.geode.cache.Operation; +import org.apache.geode.cache.PartitionAttributes; +import org.apache.geode.cache.Region; +import org.apache.geode.cache.RegionAccessException; +import org.apache.geode.cache.RegionAttributes; +import org.apache.geode.cache.RegionDestroyedException; +import org.apache.geode.cache.RegionMembershipListener; +import org.apache.geode.cache.RegionService; +import org.apache.geode.cache.RoleException; +import org.apache.geode.cache.Scope; +import org.apache.geode.cache.StatisticsDisabledException; +import org.apache.geode.cache.SubscriptionAttributes; +import org.apache.geode.cache.TimeoutException; import org.apache.geode.cache.asyncqueue.internal.AsyncEventQueueImpl; import org.apache.geode.cache.client.PoolManager; import org.apache.geode.cache.client.internal.PoolImpl; -import org.apache.geode.cache.query.*; +import org.apache.geode.cache.query.FunctionDomainException; +import org.apache.geode.cache.query.NameResolutionException; +import org.apache.geode.cache.query.QueryInvocationTargetException; +import org.apache.geode.cache.query.SelectResults; +import org.apache.geode.cache.query.TypeMismatchException; import org.apache.geode.cache.query.internal.index.IndexManager; import org.apache.geode.cache.snapshot.RegionSnapshotService; import org.apache.geode.cache.wan.GatewaySender; @@ -31,6 +81,7 @@ import org.apache.geode.distributed.internal.DM; import org.apache.geode.distributed.internal.DistributionAdvisor; import org.apache.geode.distributed.internal.DistributionConfig; import org.apache.geode.distributed.internal.InternalDistributedSystem; +import org.apache.geode.distributed.internal.membership.InternalDistributedMember; import org.apache.geode.internal.DataSerializableFixedID; import org.apache.geode.internal.cache.extension.Extensible; import org.apache.geode.internal.cache.extension.ExtensionPoint; @@ -42,23 +93,14 @@ import org.apache.geode.internal.logging.LogService; import org.apache.geode.internal.logging.log4j.LocalizedMessage; import org.apache.geode.internal.util.ArrayUtils; import org.apache.geode.pdx.internal.PeerTypeRegistration; -import org.apache.logging.log4j.Logger; - -import java.io.DataInput; -import java.io.DataOutput; -import java.io.File; -import java.io.IOException; -import java.util.*; -import java.util.concurrent.CopyOnWriteArraySet; -import java.util.concurrent.atomic.AtomicLong; /** * Takes care of RegionAttributes, AttributesMutator, and some no-brainer method implementations. - * */ @SuppressWarnings("deprecation") public abstract class AbstractRegion implements Region, RegionAttributes, AttributesMutator, CacheStatistics, DataSerializableFixedID, RegionEntryContext, Extensible> { + private static final Logger logger = LogService.getLogger(); /** @@ -67,7 +109,6 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib */ private final int serialNumber; - // RegionAttributes // /** * Used to synchronize WRITES to cacheListeners. Always do copy on write. */ @@ -89,11 +130,15 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib private LRUAlgorithm evictionController; protected int entryIdleTimeout; - protected ExpirationAction entryIdleTimeoutExpirationAction; + + private ExpirationAction entryIdleTimeoutExpirationAction; + protected CustomExpiry customEntryIdleTimeout; protected int entryTimeToLive; - protected ExpirationAction entryTimeToLiveExpirationAction; + + ExpirationAction entryTimeToLiveExpirationAction; + protected CustomExpiry customEntryTimeToLive; protected int initialCapacity; @@ -108,20 +153,21 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib protected int regionIdleTimeout; - protected ExpirationAction regionIdleTimeoutExpirationAction; + private ExpirationAction regionIdleTimeoutExpirationAction; protected int regionTimeToLive; - protected ExpirationAction regionTimeToLiveExpirationAction; + private ExpirationAction regionTimeToLiveExpirationAction; public static final Scope DEFAULT_SCOPE = Scope.DISTRIBUTED_NO_ACK; + protected Scope scope = DEFAULT_SCOPE; protected boolean statisticsEnabled; protected boolean isLockGrantor; - protected boolean mcastEnabled; + private boolean mcastEnabled; protected int concurrencyLevel; @@ -129,20 +175,17 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib protected boolean earlyAck; - // merge42004: revision 42004 has not defined isPdxTypesRegion. It has come to cheetah branch from - // merge revision 39860. This is getting used in method getRemoteDsIds. - - protected final boolean isPdxTypesRegion; + private final boolean isPdxTypesRegion; protected Set gatewaySenderIds; - protected boolean isGatewaySenderEnabled = false; + private boolean isGatewaySenderEnabled = false; protected Set asyncEventQueueIds; - protected Set visibleAsyncEventQueueIds; + private Set visibleAsyncEventQueueIds; - protected Set allGatewaySenderIds; + private Set allGatewaySenderIds; protected boolean enableSubscriptionConflation; @@ -159,7 +202,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib private boolean cloningEnable = false; - protected DiskWriteAttributes diskWriteAttributes; + private DiskWriteAttributes diskWriteAttributes; protected File[] diskDirs; protected int[] diskSizes; @@ -169,14 +212,14 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib protected volatile IndexManager indexManager = null; - // Asif : The ThreadLocal is used to identify if the thread is an + // The ThreadLocal is used to identify if the thread is an // index creation thread. This identification helps skip the synchronization // block // if the value is "REMOVED" token. This prevents the dead lock , in case the // lock // over the entry is held by any Index Update Thread. // This is used to fix Bug # 33336. - private final ThreadLocal isIndexCreator = new ThreadLocal(); + private static final ThreadLocal isIndexCreator = new ThreadLocal<>(); /** Attributes that define this Region as a PartitionedRegion */ protected PartitionAttributes partitionAttributes; @@ -198,6 +241,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib private static final boolean trackHits = !Boolean.getBoolean(DistributionConfig.GEMFIRE_PREFIX + "ignoreHits"); + private static final boolean trackMisses = !Boolean.getBoolean(DistributionConfig.GEMFIRE_PREFIX + "ignoreMisses"); @@ -213,19 +257,19 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * @see #getExtensionPoint() * @since GemFire 8.1 */ - protected ExtensionPoint> extensionPoint = + private ExtensionPoint> extensionPoint = new SimpleExtensionPoint>(this, this); - protected final GemFireCacheImpl cache; + protected final InternalCache cache; /** Creates a new instance of AbstractRegion */ - protected AbstractRegion(GemFireCacheImpl cache, RegionAttributes attrs, String regionName, + protected AbstractRegion(InternalCache cache, RegionAttributes attrs, String regionName, InternalRegionArguments internalRegionArgs) { this.cache = cache; this.serialNumber = DistributionAdvisor.createSerialNumber(); this.isPdxTypesRegion = PeerTypeRegistration.REGION_NAME.equals(regionName); this.lastAccessedTime = new AtomicLong(cacheTimeMillis()); - this.lastModifiedTime = new AtomicLong(lastAccessedTime.get()); + this.lastModifiedTime = new AtomicLong(this.lastAccessedTime.get()); setAttributes(attrs, regionName, internalRegionArgs); } @@ -234,11 +278,11 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * * @since GemFire 8.1 * @deprecated For unit testing only. Use - * {@link #AbstractRegion(GemFireCacheImpl, RegionAttributes, String, InternalRegionArguments)} + * {@link #AbstractRegion(InternalCache, RegionAttributes, String, InternalRegionArguments)} * . */ @Deprecated - AbstractRegion(GemFireCacheImpl cache, int serialNumber, boolean isPdxTypeRegion, + AbstractRegion(InternalCache cache, int serialNumber, boolean isPdxTypeRegion, long lastAccessedTime, long lastModifiedTime) { this.cache = cache; this.serialNumber = serialNumber; @@ -247,8 +291,6 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib this.lastModifiedTime = new AtomicLong(lastModifiedTime); } - /** ******************** No-Brainer methods ******************************** */ - /** * configure this region to ignore or not ignore in-progress JTA transactions. Setting this to * true will cause cache operations to no longer notice JTA transactions. The default setting is @@ -258,33 +300,39 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib */ @Deprecated public void setIgnoreJTA(boolean ignore) { - ignoreJTA = ignore; + this.ignoreJTA = ignore; } - public final void create(Object key, Object value) + @Override + public void create(Object key, Object value) throws TimeoutException, EntryExistsException, CacheWriterException { create(key, value, null); } - public final Object destroy(Object key) + @Override + public Object destroy(Object key) throws TimeoutException, EntryNotFoundException, CacheWriterException { return destroy(key, null); } - public Object get(Object name) throws CacheLoaderException, TimeoutException { - return get(name, null, true, null); + @Override + public Object get(Object key) throws CacheLoaderException, TimeoutException { + return get(key, null, true, null); } - public Object put(Object name, Object value) throws TimeoutException, CacheWriterException { - return put(name, value, null); + @Override + public Object put(Object key, Object value) throws TimeoutException, CacheWriterException { + return put(key, value, null); } - public Object get(Object name, Object aCallbackArgument) + @Override + public Object get(Object key, Object aCallbackArgument) throws CacheLoaderException, TimeoutException { - return get(name, aCallbackArgument, true, null); + return get(key, aCallbackArgument, true, null); } - public final void localDestroyRegion() { + @Override + public void localDestroyRegion() { localDestroyRegion(null); } @@ -294,32 +342,36 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * @param generateCallbacks whether callbacks should be invoked * @param clientEvent client-side event, if any (used to pass back version information) * @return the value associated with the key - * @throws TimeoutException - * @throws CacheLoaderException */ abstract Object get(Object key, Object aCallbackArgument, boolean generateCallbacks, EntryEventImpl clientEvent) throws TimeoutException, CacheLoaderException; + @Override public final void localDestroy(Object key) throws EntryNotFoundException { localDestroy(key, null); } + @Override public final void destroyRegion() throws CacheWriterException, TimeoutException { destroyRegion(null); } + @Override public final void invalidate(Object key) throws TimeoutException, EntryNotFoundException { invalidate(key, null); } + @Override public final void localInvalidate(Object key) throws EntryNotFoundException { localInvalidate(key, null); } + @Override public final void localInvalidateRegion() { localInvalidateRegion(null); } + @Override public final void invalidateRegion() throws TimeoutException { invalidateRegion(null); } @@ -337,8 +389,9 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib */ abstract boolean generateEventID(); - protected abstract DistributedMember getMyId(); + protected abstract InternalDistributedMember getMyId(); + @Override public void clear() { checkReadiness(); checkForLimitedOrNoAccess(); @@ -349,6 +402,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib abstract void basicLocalClear(RegionEventImpl rEvent); + @Override public void localClear() { checkReadiness(); checkForNoAccess(); @@ -363,13 +417,13 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } @Override - public Map getAll(Collection keys, Object callback) { + public Map getAll(Collection keys, Object aCallbackArgument) { if (keys == null) { throw new NullPointerException("The collection of keys for getAll cannot be null"); } checkReadiness(); checkForLimitedOrNoAccess(); - return keys.isEmpty() ? new HashMap() : basicGetAll(keys, callback); + return keys.isEmpty() ? new HashMap() : basicGetAll(keys, aCallbackArgument); } abstract Map basicGetAll(Collection keys, Object callback); @@ -392,15 +446,13 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return getStringBuilder().append(']').toString(); } - /** ********************* RegionAttributes ********************************* */ - + @Override public CacheLoader getCacheLoader() { - // checkReadiness(); return this.cacheLoader; } + @Override public CacheWriter getCacheWriter() { - // checkReadiness(); return this.cacheWriter; } @@ -410,9 +462,8 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * * @since GemFire 5.7 */ - public CacheLoader basicGetLoader() { - CacheLoader result = this.cacheLoader; - return result; + CacheLoader basicGetLoader() { + return this.cacheLoader; } /** @@ -422,15 +473,15 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * @since GemFire 5.7 */ public CacheWriter basicGetWriter() { - CacheWriter result = this.cacheWriter; - return result; + return this.cacheWriter; } + @Override public Class getKeyConstraint() { - // checkReadiness(); return this.keyConstraint; } + @Override public Class getValueConstraint() { return this.valueConstraint; } @@ -442,51 +493,58 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib new ExpirationAttributes(this.regionTimeToLive, this.regionTimeToLiveExpirationAction); } + @Override public ExpirationAttributes getRegionTimeToLive() { return this.regionTimeToLiveAtts; } - private volatile ExpirationAttributes regionIdleTimeoutAtts; + private volatile ExpirationAttributes regionIdleTimeoutAttributes; - private void setRegionIdleTimeoutAtts() { - this.regionIdleTimeoutAtts = + private void setRegionIdleTimeoutAttributes() { + this.regionIdleTimeoutAttributes = new ExpirationAttributes(this.regionIdleTimeout, this.regionIdleTimeoutExpirationAction); } + @Override public ExpirationAttributes getRegionIdleTimeout() { - return this.regionIdleTimeoutAtts; + return this.regionIdleTimeoutAttributes; } private volatile ExpirationAttributes entryTimeToLiveAtts; - protected void setEntryTimeToLiveAtts() { + void setEntryTimeToLiveAttributes() { this.entryTimeToLiveAtts = new ExpirationAttributes(this.entryTimeToLive, this.entryTimeToLiveExpirationAction); } + @Override public ExpirationAttributes getEntryTimeToLive() { return this.entryTimeToLiveAtts; } + @Override public CustomExpiry getCustomEntryTimeToLive() { return this.customEntryTimeToLive; } - private volatile ExpirationAttributes entryIdleTimeoutAtts; + private volatile ExpirationAttributes entryIdleTimeoutAttributes; - protected void setEntryIdleTimeoutAtts() { - this.entryIdleTimeoutAtts = + private void setEntryIdleTimeoutAttributes() { + this.entryIdleTimeoutAttributes = new ExpirationAttributes(this.entryIdleTimeout, this.entryIdleTimeoutExpirationAction); } + @Override public ExpirationAttributes getEntryIdleTimeout() { - return this.entryIdleTimeoutAtts; + return this.entryIdleTimeoutAttributes; } + @Override public CustomExpiry getCustomEntryIdleTimeout() { return this.customEntryIdleTimeout; } + @Override public MirrorType getMirrorType() { if (this.dataPolicy.isNormal() || this.dataPolicy.isPreloaded() || this.dataPolicy.isEmpty() || this.dataPolicy.withPartitioning()) { @@ -500,24 +558,23 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } - + @Override public String getPoolName() { - // checkReadiness(); return this.poolName; } + @Override public DataPolicy getDataPolicy() { - // checkReadiness(); return this.dataPolicy; } + @Override public Scope getScope() { - // checkReadiness(); return this.scope; } + @Override public CacheListener getCacheListener() { - // checkReadiness(); CacheListener[] listeners = fetchCacheListenersField(); if (listeners == null || listeners.length == 0) { return null; @@ -530,93 +587,44 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } - public final boolean isPdxTypesRegion() { + public boolean isPdxTypesRegion() { return this.isPdxTypesRegion; } + @Override public Set getGatewaySenderIds() { return this.gatewaySenderIds; } + @Override public Set getAsyncEventQueueIds() { return this.asyncEventQueueIds; } - public Set getVisibleAsyncEventQueueIds() { + Set getVisibleAsyncEventQueueIds() { return this.visibleAsyncEventQueueIds; } - public final Set getAllGatewaySenderIds() { + public Set getAllGatewaySenderIds() { return Collections.unmodifiableSet(this.allGatewaySenderIds); } - public final boolean checkNotifyGatewaySender() { - return (this.cache.getAllGatewaySenders().size() > 0 && this.allGatewaySenderIds.size() > 0); - } - - public final Set getActiveGatewaySenderIds() { - final Set allGatewaySenders; - HashSet activeGatewaySenderIds = null; - final int sz = this.gatewaySenderIds.size(); - if (sz > 0 && (allGatewaySenders = this.cache.getGatewaySenders()).size() > 0) { - for (GatewaySender sender : allGatewaySenders) { - if (sender.isRunning() && this.gatewaySenderIds.contains(sender.getId())) { - if (activeGatewaySenderIds == null) { - activeGatewaySenderIds = new HashSet(); - } - activeGatewaySenderIds.add(sender.getId()); - } - } - } - return activeGatewaySenderIds; - } - - public final Set getActiveAsyncQueueIds() { - final Set allAsyncQueues; - HashSet activeAsyncQueueIds = null; - final int sz = this.asyncEventQueueIds.size(); - if (sz > 0 && (allAsyncQueues = this.cache.getAsyncEventQueues()).size() > 0) { - for (AsyncEventQueue asyncQueue : allAsyncQueues) { - // merge42004:In cheetah asyncEventQueue has isRunning Method. It has come from merging - // branches. A mail regarding the asyncEventQueue is sent to Barry to get more - // clarification. We need to sort this out. - if (/* - * asyncQueue.isRunning() && - */ this.asyncEventQueueIds.contains(asyncQueue.getId())) { - if (activeAsyncQueueIds == null) { - activeAsyncQueueIds = new HashSet(); - } - activeAsyncQueueIds.add(asyncQueue.getId()); - } - } - } - return activeAsyncQueueIds; - } - /** * Return the remote DS IDs that need to receive events for this region. * * @param allGatewaySenderIds the set of gateway sender IDs to consider */ - public final List getRemoteDsIds(Set allGatewaySenderIds) - throws IllegalStateException { - final Set allGatewaySenders; - final int sz = allGatewaySenderIds.size(); - if ((sz > 0 || isPdxTypesRegion) - && (allGatewaySenders = this.cache.getAllGatewaySenders()).size() > 0) { - List allRemoteDSIds = new ArrayList(sz); + List getRemoteDsIds(Set allGatewaySenderIds) throws IllegalStateException { + int sz = allGatewaySenderIds.size(); + Set allGatewaySenders = this.cache.getAllGatewaySenders(); + if ((sz > 0 || this.isPdxTypesRegion) && !allGatewaySenders.isEmpty()) { + List allRemoteDSIds = new ArrayList<>(sz); for (GatewaySender sender : allGatewaySenders) { // This is for all regions except pdx Region - if (!isPdxTypesRegion) { + if (!this.isPdxTypesRegion) { // Make sure we are distributing to only those senders whose id - // is avaialble on this region + // is available on this region if (allGatewaySenderIds.contains(sender.getId())) { - /* - * // ParalleGatewaySender with DR is not allowed if (this.partitionAttributes == null - * && sender.isParallel()) { throw new IllegalStateException(LocalizedStrings - * .AttributesFactory_PARALLELGATEWAYSENDER_0_IS_INCOMPATIBLE_WITH_DISTRIBUTED_REPLICATION - * .toLocalizedString(sender.getId())); } - */ allRemoteDSIds.add(sender.getRemoteDSId()); } } else { // this else is for PDX region @@ -628,26 +636,13 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return null; } - // protected final void initAllGatewaySenderIds() { - // HashSet senderIds = new HashSet(); - // this.allGatewaySenderIds = senderIds; - // if (getGatewaySenderIds().isEmpty() && getAsyncEventQueueIds().isEmpty()) { - // return Collections.emptySet(); // fix for bug 45774 - // } - // Set tmp = new CopyOnWriteArraySet(); - // tmp.addAll(this.getGatewaySenderIds()); - // for(String asyncQueueId : this.getAsyncEventQueueIds()){ - // tmp.add(AsyncEventQueueImpl.getSenderIdFromAsyncEventQueueId(asyncQueueId)); - // } - // return tmp; - // } - - public boolean isGatewaySenderEnabled() { + boolean isGatewaySenderEnabled() { return this.isGatewaySenderEnabled; } private static final CacheListener[] EMPTY_LISTENERS = new CacheListener[0]; + @Override public CacheListener[] getCacheListeners() { CacheListener[] listeners = fetchCacheListenersField(); if (listeners == null || listeners.length == 0) { @@ -662,12 +657,12 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib /** * Sets the cacheListeners field. */ - private final void storeCacheListenersField(CacheListener[] value) { + private void storeCacheListenersField(CacheListener[] value) { synchronized (this.clSync) { if (value != null && value.length != 0) { - CacheListener[] nv = new CacheListener[value.length]; - System.arraycopy(value, 0, nv, 0, nv.length); - value = nv; + CacheListener[] cacheListeners = new CacheListener[value.length]; + System.arraycopy(value, 0, cacheListeners, 0, cacheListeners.length); + value = cacheListeners; } else { value = EMPTY_LISTENERS; } @@ -679,24 +674,24 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * Fetches the value in the cacheListeners field. NOTE: callers should not modify the contents of * the returned array. */ - protected final CacheListener[] fetchCacheListenersField() { + CacheListener[] fetchCacheListenersField() { return this.cacheListeners; } + @Override public int getInitialCapacity() { - // checkReadiness(); return this.initialCapacity; } + @Override public float getLoadFactor() { - // checkReadiness(); return this.loadFactor; } protected abstract boolean isCurrentlyLockGrantor(); + @Override public boolean isLockGrantor() { - // checkReadiness(); return this.isLockGrantor; } @@ -704,37 +699,38 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * RegionAttributes implementation. Returns true if multicast can be used by the cache for this * region */ + @Override public boolean getMulticastEnabled() { - // checkReadiness(); return this.mcastEnabled; } + @Override public boolean getStatisticsEnabled() { - // checkReadiness(); return this.statisticsEnabled; } + @Override public boolean getIgnoreJTA() { - // checkRediness(); return this.ignoreJTA; } + @Override public int getConcurrencyLevel() { - // checkReadiness(); return this.concurrencyLevel; } + @Override public boolean getConcurrencyChecksEnabled() { return this.concurrencyChecksEnabled; } + @Override public boolean getPersistBackup() { - // checkReadiness(); return getDataPolicy().withPersistence(); } + @Override public boolean getEarlyAck() { - // checkReadiness(); return this.earlyAck; } @@ -742,22 +738,27 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * @deprecated as of prPersistSprint1 */ @Deprecated + @Override public boolean getPublisher() { return this.publisher; } + @Override public boolean getEnableConflation() { // deprecated in 5.0 return getEnableSubscriptionConflation(); } + @Override public boolean getEnableBridgeConflation() {// deprecated in 5.7 return getEnableSubscriptionConflation(); } + @Override public boolean getEnableSubscriptionConflation() { return this.enableSubscriptionConflation; } + @Override public boolean getEnableAsyncConflation() { return this.enableAsyncConflation; } @@ -766,33 +767,40 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * @deprecated as of prPersistSprint2 */ @Deprecated + @Override public DiskWriteAttributes getDiskWriteAttributes() { - // checkReadiness(); return this.diskWriteAttributes; } + @Override public abstract File[] getDiskDirs(); - public final String getDiskStoreName() { + @Override + public String getDiskStoreName() { return this.diskStoreName; } + @Override public boolean isDiskSynchronous() { return this.isDiskSynchronous; } + @Override public boolean getIndexMaintenanceSynchronous() { return this.indexMaintenanceSynchronous; } + @Override public PartitionAttributes getPartitionAttributes() { return this.partitionAttributes; } + @Override public MembershipAttributes getMembershipAttributes() { return this.membershipAttributes; } + @Override public SubscriptionAttributes getSubscriptionAttributes() { return this.subscriptionAttributes; } @@ -820,50 +828,37 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * @return {@link IndexManager} lock. */ public Object getIMSync() { - return imSync; + return this.imSync; } - // Asif : The ThreadLocal is used to identify if the thread is an + // The ThreadLocal is used to identify if the thread is an // index creation thread. This is used to fix Bug # 33336. The value // is set from IndexManager ,if the thread happens to be an IndexCreation // Thread. // Once the thread has created the Index , it will unset the value in the // ThreadLocal Object - public void setFlagForIndexCreationThread(boolean bool) { - this.isIndexCreator.set(bool ? Boolean.TRUE : null); + public void setFlagForIndexCreationThread(boolean value) { + isIndexCreator.set(value ? Boolean.TRUE : null); } - // Asif : The boolean is used in AbstractRegionEntry to skip the synchronized + // The boolean is used in AbstractRegionEntry to skip the synchronized // block // in case the value of the entry is "REMOVED" token. This prevents dead lock // caused by the Bug # 33336 boolean isIndexCreationThread() { - Boolean bool = (Boolean) this.isIndexCreator.get(); - return (bool != null) ? bool.booleanValue() : false; + Boolean value = isIndexCreator.get(); + return value != null ? value : false; } - /** ********************* AttributesMutator ******************************** */ - + @Override public Region getRegion() { return this; } - // /** - // * A CacheListener implementation that delegates to an array of listeners. - // */ - // public static class ArrayCacheListener implements CacheListener { - // private final CacheListener [] listeners; - // /** - // * Creates a cache listener given the list of listeners it will delegate to. - // */ - // public ArrayCacheListener(CacheListener[] listeners) { - // this.listeners = listeners; - // } - // } + @Override public CacheListener setCacheListener(CacheListener aListener) { checkReadiness(); - CacheListener result = null; - CacheListener[] oldListeners = null; + CacheListener[] oldListeners; synchronized (this.clSync) { oldListeners = this.cacheListeners; if (oldListeners != null && oldListeners.length > 1) { @@ -874,13 +869,14 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib this.cacheListeners = new CacheListener[] {aListener}; } // moved the following out of the sync for bug 34512 + CacheListener result = null; if (oldListeners != null && oldListeners.length > 0) { if (oldListeners.length == 1) { result = oldListeners[0]; } - for (int i = 0; i < oldListeners.length; i++) { - if (aListener != oldListeners[i]) { - closeCacheCallback(oldListeners[i]); + for (CacheListener oldListener : oldListeners) { + if (aListener != oldListener) { + closeCacheCallback(oldListener); } } if (aListener == null) { @@ -895,22 +891,26 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return result; } + @Override public void addGatewaySenderId(String gatewaySenderId) { getGatewaySenderIds().add(gatewaySenderId); setAllGatewaySenderIds(); } + @Override public void removeGatewaySenderId(String gatewaySenderId) { getGatewaySenderIds().remove(gatewaySenderId); setAllGatewaySenderIds(); } + @Override public void addAsyncEventQueueId(String asyncEventQueueId) { getAsyncEventQueueIds().add(asyncEventQueueId); getVisibleAsyncEventQueueIds().add(asyncEventQueueId); setAllGatewaySenderIds(); } + @Override public void removeAsyncEventQueueId(String asyncEventQueueId) { getAsyncEventQueueIds().remove(asyncEventQueueId); getVisibleAsyncEventQueueIds().remove(asyncEventQueueId); @@ -919,34 +919,35 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib private void setAllGatewaySenderIds() { if (getGatewaySenderIds().isEmpty() && getAsyncEventQueueIds().isEmpty()) { - allGatewaySenderIds = Collections.emptySet(); // fix for bug 45774 + this.allGatewaySenderIds = Collections.emptySet(); // fix for bug 45774 } Set tmp = new CopyOnWriteArraySet(); tmp.addAll(this.getGatewaySenderIds()); for (String asyncQueueId : this.getAsyncEventQueueIds()) { tmp.add(AsyncEventQueueImpl.getSenderIdFromAsyncEventQueueId(asyncQueueId)); } - allGatewaySenderIds = tmp; + this.allGatewaySenderIds = tmp; } private void initializeVisibleAsyncEventQueueIds(InternalRegionArguments internalRegionArgs) { - Set asyncEventQueueIds = new CopyOnWriteArraySet<>(); + Set visibleAsyncEventQueueIds = new CopyOnWriteArraySet<>(); // Add all configured aeqIds - asyncEventQueueIds.addAll(getAsyncEventQueueIds()); + visibleAsyncEventQueueIds.addAll(getAsyncEventQueueIds()); // Remove all internal aeqIds from internal region args if necessary if (internalRegionArgs.getInternalAsyncEventQueueIds() != null) { - asyncEventQueueIds.removeAll(internalRegionArgs.getInternalAsyncEventQueueIds()); + visibleAsyncEventQueueIds.removeAll(internalRegionArgs.getInternalAsyncEventQueueIds()); } - this.visibleAsyncEventQueueIds = asyncEventQueueIds; + this.visibleAsyncEventQueueIds = visibleAsyncEventQueueIds; } - public void addCacheListener(CacheListener cl) { + @Override + public void addCacheListener(CacheListener aListener) { checkReadiness(); - if (cl == null) { + if (aListener == null) { throw new IllegalArgumentException( LocalizedStrings.AbstractRegion_ADDCACHELISTENER_PARAMETER_WAS_NULL.toLocalizedString()); } - CacheListener wcl = wrapRegionMembershipListener(cl); + CacheListener wcl = wrapRegionMembershipListener(aListener); boolean changed = false; synchronized (this.clSync) { CacheListener[] oldListeners = this.cacheListeners; @@ -954,8 +955,8 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib this.cacheListeners = new CacheListener[] {wcl}; changed = true; } else { - List l = Arrays.asList(oldListeners); - if (!l.contains(cl)) { + List listeners = Arrays.asList(oldListeners); + if (!listeners.contains(aListener)) { this.cacheListeners = (CacheListener[]) ArrayUtils.insert(oldListeners, oldListeners.length, wcl); } @@ -971,57 +972,57 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * We wrap RegionMembershipListeners in a container when adding them at runtime, so that we can * properly initialize their membership set prior to delivering events to them. * - * @param cl a cache listener to be added to the region + * @param listener a cache listener to be added to the region */ - private CacheListener wrapRegionMembershipListener(CacheListener cl) { - if (cl instanceof RegionMembershipListener) { - return new WrappedRegionMembershipListener((RegionMembershipListener) cl); + private CacheListener wrapRegionMembershipListener(CacheListener listener) { + if (listener instanceof RegionMembershipListener) { + return new WrappedRegionMembershipListener((RegionMembershipListener) listener); } - return cl; + return listener; } /** * Initialize any wrapped RegionMembershipListeners in the cache listener list */ void initPostCreateRegionMembershipListeners(Set initialMembers) { - DistributedMember[] initMbrs = null; - CacheListener[] newcl = null; - synchronized (clSync) { - for (int i = 0; i < cacheListeners.length; i++) { - CacheListener cl = cacheListeners[i]; + synchronized (this.clSync) { + DistributedMember[] members = null; + CacheListener[] newListeners = null; + for (int i = 0; i < this.cacheListeners.length; i++) { + CacheListener cl = this.cacheListeners[i]; if (cl instanceof WrappedRegionMembershipListener) { WrappedRegionMembershipListener wrml = (WrappedRegionMembershipListener) cl; if (!wrml.isInitialized()) { - if (initMbrs == null) { - initMbrs = (DistributedMember[]) initialMembers + if (members == null) { + members = (DistributedMember[]) initialMembers .toArray(new DistributedMember[initialMembers.size()]); } - wrml.initialMembers(this, initMbrs); - if (newcl == null) { - newcl = new CacheListener[cacheListeners.length]; - System.arraycopy(cacheListeners, 0, newcl, 0, newcl.length); + wrml.initialMembers(this, members); + if (newListeners == null) { + newListeners = new CacheListener[this.cacheListeners.length]; + System.arraycopy(this.cacheListeners, 0, newListeners, 0, newListeners.length); } - newcl[i] = wrml.getWrappedListener(); + newListeners[i] = wrml.getWrappedListener(); } } } - if (newcl != null) { - cacheListeners = newcl; + if (newListeners != null) { + this.cacheListeners = newListeners; } } } - - public void initCacheListeners(CacheListener[] addedListeners) { + @Override + public void initCacheListeners(CacheListener[] newListeners) { checkReadiness(); - CacheListener[] oldListeners = null; CacheListener[] listenersToAdd = null; - if (addedListeners != null) { - listenersToAdd = new CacheListener[addedListeners.length]; - for (int i = 0; i < addedListeners.length; i++) { - listenersToAdd[i] = wrapRegionMembershipListener(addedListeners[i]); + if (newListeners != null) { + listenersToAdd = new CacheListener[newListeners.length]; + for (int i = 0; i < newListeners.length; i++) { + listenersToAdd[i] = wrapRegionMembershipListener(newListeners[i]); } } + CacheListener[] oldListeners; synchronized (this.clSync) { oldListeners = this.cacheListeners; if (listenersToAdd == null || listenersToAdd.length == 0) { @@ -1032,23 +1033,23 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib LocalizedStrings.AbstractRegion_INITCACHELISTENERS_PARAMETER_HAD_A_NULL_ELEMENT .toLocalizedString()); } - CacheListener[] newListeners = new CacheListener[listenersToAdd.length]; - System.arraycopy(listenersToAdd, 0, newListeners, 0, newListeners.length); - this.cacheListeners = newListeners; + CacheListener[] newCacheListeners = new CacheListener[listenersToAdd.length]; + System.arraycopy(listenersToAdd, 0, newCacheListeners, 0, newCacheListeners.length); + this.cacheListeners = newCacheListeners; } } // moved the following out of the sync for bug 34512 if (listenersToAdd == null || listenersToAdd.length == 0) { if (oldListeners != null && oldListeners.length > 0) { - for (int i = 0; i < oldListeners.length; i++) { - closeCacheCallback(oldListeners[i]); + for (CacheListener oldListener : oldListeners) { + closeCacheCallback(oldListener); } cacheListenersChanged(false); } } else { // we had some listeners to add if (oldListeners != null && oldListeners.length > 0) { - for (int i = 0; i < oldListeners.length; i++) { - closeCacheCallback(oldListeners[i]); + for (CacheListener oldListener : oldListeners) { + closeCacheCallback(oldListener); } } else { cacheListenersChanged(true); @@ -1056,9 +1057,10 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } - public void removeCacheListener(CacheListener cl) { + @Override + public void removeCacheListener(CacheListener aListener) { checkReadiness(); - if (cl == null) { + if (aListener == null) { throw new IllegalArgumentException( LocalizedStrings.AbstractRegion_REMOVECACHELISTENER_PARAMETER_WAS_NULL .toLocalizedString()); @@ -1067,17 +1069,17 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib synchronized (this.clSync) { CacheListener[] oldListeners = this.cacheListeners; if (oldListeners != null && oldListeners.length > 0) { - List l = new ArrayList(Arrays.asList(oldListeners)); - if (l.remove(cl)) { - if (l.isEmpty()) { + List newListeners = new ArrayList(Arrays.asList(oldListeners)); + if (newListeners.remove(aListener)) { + if (newListeners.isEmpty()) { this.cacheListeners = EMPTY_LISTENERS; } else { - CacheListener[] newListeners = new CacheListener[l.size()]; - l.toArray(newListeners); - this.cacheListeners = newListeners; + CacheListener[] newCacheListeners = new CacheListener[newListeners.size()]; + newListeners.toArray(newCacheListeners); + this.cacheListeners = newCacheListeners; } - closeCacheCallback(cl); - if (l.isEmpty()) { + closeCacheCallback(aListener); + if (newListeners.isEmpty()) { changed = true; } } @@ -1088,11 +1090,11 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } - // synchronized so not reentrant - public synchronized CacheLoader setCacheLoader(CacheLoader cl) { + @Override + public synchronized CacheLoader setCacheLoader(CacheLoader cacheLoader) { checkReadiness(); CacheLoader oldLoader = this.cacheLoader; - assignCacheLoader(cl); + assignCacheLoader(cacheLoader); cacheLoaderChanged(oldLoader); return oldLoader; } @@ -1101,7 +1103,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib this.cacheLoader = cl; } - // synchronized so not reentrant + @Override public synchronized CacheWriter setCacheWriter(CacheWriter cacheWriter) { checkReadiness(); CacheWriter oldWriter = this.cacheWriter; @@ -1123,6 +1125,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } + @Override public ExpirationAttributes setEntryIdleTimeout(ExpirationAttributes idleTimeout) { checkReadiness(); if (idleTimeout == null) { @@ -1139,12 +1142,13 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib ExpirationAttributes oldAttrs = getEntryIdleTimeout(); this.entryIdleTimeout = idleTimeout.getTimeout(); this.entryIdleTimeoutExpirationAction = idleTimeout.getAction(); - setEntryIdleTimeoutAtts(); + setEntryIdleTimeoutAttributes(); updateEntryExpiryPossible(); idleTimeoutChanged(oldAttrs); return oldAttrs; } + @Override public CustomExpiry setCustomEntryIdleTimeout(CustomExpiry custom) { checkReadiness(); if (custom != null && !this.statisticsEnabled) { @@ -1160,6 +1164,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return old; } + @Override public ExpirationAttributes setEntryTimeToLive(ExpirationAttributes timeToLive) { checkReadiness(); if (timeToLive == null) { @@ -1175,12 +1180,13 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib ExpirationAttributes oldAttrs = getEntryTimeToLive(); this.entryTimeToLive = timeToLive.getTimeout(); this.entryTimeToLiveExpirationAction = timeToLive.getAction(); - setEntryTimeToLiveAtts(); + setEntryTimeToLiveAttributes(); updateEntryExpiryPossible(); timeToLiveChanged(oldAttrs); return oldAttrs; } + @Override public CustomExpiry setCustomEntryTimeToLive(CustomExpiry custom) { checkReadiness(); if (custom != null && !this.statisticsEnabled) { @@ -1210,6 +1216,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } + @Override public ExpirationAttributes setRegionIdleTimeout(ExpirationAttributes idleTimeout) { checkReadiness(); if (idleTimeout == null) { @@ -1233,11 +1240,12 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib ExpirationAttributes oldAttrs = getRegionIdleTimeout(); this.regionIdleTimeout = idleTimeout.getTimeout(); this.regionIdleTimeoutExpirationAction = idleTimeout.getAction(); - this.setRegionIdleTimeoutAtts(); + this.setRegionIdleTimeoutAttributes(); regionIdleTimeoutChanged(oldAttrs); return oldAttrs; } + @Override public ExpirationAttributes setRegionTimeToLive(ExpirationAttributes timeToLive) { checkReadiness(); if (timeToLive == null) { @@ -1267,6 +1275,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return oldAttrs; } + @Override public void becomeLockGrantor() { checkReadiness(); checkForLimitedOrNoAccess(); @@ -1280,8 +1289,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib this.isLockGrantor = true; } - /** ********************* CacheStatistics ******************************** */ - + @Override public CacheStatistics getStatistics() { // prefer region destroyed exception over statistics disabled exception checkReadiness(); @@ -1298,20 +1306,21 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * all its subregions. This implementation trades performance of stat retrieval for performance of * get/put, which is more critical. */ + @Override public synchronized long getLastModifiedTime() { checkReadiness(); long mostRecent = basicGetLastModifiedTime(); + // don't need to wait on getInitialImage for this operation in subregions int oldLevel = LocalRegion.setThreadInitLevelRequirement(LocalRegion.ANY_INIT); try { - Iterator subIt = subregions(false).iterator(); - while (subIt.hasNext()) { + for (Object region : subregions(false)) { try { - LocalRegion r = (LocalRegion) subIt.next(); - if (r.isInitialized()) { - mostRecent = Math.max(mostRecent, r.getLastModifiedTime()); + LocalRegion localRegion = (LocalRegion) region; + if (localRegion.isInitialized()) { + mostRecent = Math.max(mostRecent, localRegion.getLastModifiedTime()); } - } catch (RegionDestroyedException e) { + } catch (RegionDestroyedException ignore) { // pass over destroyed region } } @@ -1321,19 +1330,19 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return mostRecent; } - protected long basicGetLastModifiedTime() { + private long basicGetLastModifiedTime() { return this.lastModifiedTime.get(); } - protected long basicGetLastAccessedTime() { + private long basicGetLastAccessedTime() { return this.lastAccessedTime.get(); } - protected void basicSetLastModifiedTime(long t) { + private void basicSetLastModifiedTime(long t) { this.lastModifiedTime.set(t); } - protected void basicSetLastAccessedTime(long t) { + private void basicSetLastAccessedTime(long t) { this.lastAccessedTime.set(t); } @@ -1342,20 +1351,20 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * all its subregions. This implementation trades performance of stat retrieval for performance of * get/put, which is more critical. */ + @Override public synchronized long getLastAccessedTime() { checkReadiness(); long mostRecent = basicGetLastAccessedTime(); // don't need to wait on getInitialImage for this operation in subregions int oldLevel = LocalRegion.setThreadInitLevelRequirement(LocalRegion.ANY_INIT); try { - Iterator subIt = subregions(false).iterator(); - while (subIt.hasNext()) { + for (Object region : subregions(false)) { try { - LocalRegion r = (LocalRegion) subIt.next(); - if (r.isInitialized()) { - mostRecent = Math.max(mostRecent, r.getLastAccessedTime()); + LocalRegion localRegion = (LocalRegion) region; + if (localRegion.isInitialized()) { + mostRecent = Math.max(mostRecent, localRegion.getLastAccessedTime()); } - } catch (RegionDestroyedException e) { + } catch (RegionDestroyedException ignore) { // pass over destroyed region } } @@ -1371,18 +1380,18 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib protected synchronized void updateStats() { long mostRecentAccessed = basicGetLastAccessedTime(); long mostRecentModified = basicGetLastModifiedTime(); + // don't need to wait on getInitialImage for this operation in subregions int oldLevel = LocalRegion.setThreadInitLevelRequirement(LocalRegion.ANY_INIT); try { - Iterator subIt = subregions(false).iterator(); - while (subIt.hasNext()) { + for (Object region : subregions(false)) { try { - LocalRegion r = (LocalRegion) subIt.next(); - if (r.isInitialized()) { - mostRecentAccessed = Math.max(mostRecentAccessed, r.getLastAccessedTime()); - mostRecentModified = Math.max(mostRecentModified, r.getLastModifiedTime()); + LocalRegion localRegion = (LocalRegion) region; + if (localRegion.isInitialized()) { + mostRecentAccessed = Math.max(mostRecentAccessed, localRegion.getLastAccessedTime()); + mostRecentModified = Math.max(mostRecentModified, localRegion.getLastModifiedTime()); } - } catch (RegionDestroyedException e) { + } catch (RegionDestroyedException ignore) { // pass over destroyed region } } @@ -1394,7 +1403,6 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } protected void setLastModifiedTime(long time) { - // checkReadiness(); if (time > this.lastModifiedTime.get()) { this.lastModifiedTime.set(time); } @@ -1403,7 +1411,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } - protected void setLastAccessedTime(long time, boolean hit) { + void setLastAccessedTime(long time, boolean hit) { this.lastAccessedTime.set(time); if (hit) { if (trackHits) { @@ -1416,25 +1424,25 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } - public final float getHitRatio() { - // checkReadiness(); + @Override + public float getHitRatio() { long hits = getHitCount(); long total = hits + getMissCount(); - return total == 0L ? 0.0f : ((float) hits / total); + return total == 0L ? 0.0f : (float) hits / total; } + @Override public long getHitCount() { - // checkReadiness(); return this.hitCount.get(); } + @Override public long getMissCount() { - // checkReadiness(); return this.missCount.get(); } + @Override public void resetCounts() { - // checkReadiness(); if (trackMisses) { this.missCount.set(0); } @@ -1443,9 +1451,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } - /** ****************** Protected Methods *********************************** */ - - protected void closeCacheCallback(CacheCallback cb) { + void closeCacheCallback(CacheCallback cb) { if (cb != null) { try { cb.close(); @@ -1479,13 +1485,21 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib } } - protected void timeToLiveChanged(ExpirationAttributes oldTimeToLive) {} + protected void timeToLiveChanged(ExpirationAttributes oldTimeToLive) { + // nothing + } - protected void idleTimeoutChanged(ExpirationAttributes oldIdleTimeout) {} + protected void idleTimeoutChanged(ExpirationAttributes oldIdleTimeout) { + // nothing + } - protected void regionTimeToLiveChanged(ExpirationAttributes oldTimeToLive) {} + protected void regionTimeToLiveChanged(ExpirationAttributes oldTimeToLive) { + // nothing + } - protected void regionIdleTimeoutChanged(ExpirationAttributes oldIdleTimeout) {}; + protected void regionIdleTimeoutChanged(ExpirationAttributes oldIdleTimeout) { + // nothing + } /** Throws CacheClosedException or RegionDestroyedException */ abstract void checkReadiness(); @@ -1495,7 +1509,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * * @since GemFire 5.0 */ - protected final boolean isProxy() { + protected boolean isProxy() { return getDataPolicy().isEmpty(); } @@ -1505,7 +1519,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * * @since GemFire 5.0 */ - protected final boolean isCacheContentProxy() { + boolean isCacheContentProxy() { // method added to fix bug 35195 return isProxy() && getSubscriptionAttributes().getInterestPolicy().isCacheContent(); } @@ -1523,23 +1537,30 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib private boolean entryExpiryPossible = false; protected void updateEntryExpiryPossible() { - this.entryExpiryPossible = !isProxy() && (this.entryTimeToLive > 0 || this.entryIdleTimeout > 0 - || this.customEntryIdleTimeout != null || this.customEntryTimeToLive != null); + this.entryExpiryPossible = !isProxy() && (hasTimeToLive() || hasIdleTimeout()); + } + + private boolean hasTimeToLive() { + return this.entryTimeToLive > 0 || this.customEntryTimeToLive != null; + } + + private boolean hasIdleTimeout() { + return this.entryIdleTimeout > 0 || this.customEntryIdleTimeout != null; } /** * Returns true if this region could expire an entry */ - protected boolean isEntryExpiryPossible() { + boolean isEntryExpiryPossible() { return this.entryExpiryPossible; } - public ExpirationAction getEntryExpirationAction() { + ExpirationAction getEntryExpirationAction() { if (this.entryIdleTimeoutExpirationAction != null) { - return entryIdleTimeoutExpirationAction; + return this.entryIdleTimeoutExpirationAction; } if (this.entryTimeToLiveExpirationAction != null) { - return entryTimeToLiveExpirationAction; + return this.entryTimeToLiveExpirationAction; } return null; } @@ -1551,7 +1572,6 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return this.evictionController != null; } - /** ****************** Private Methods ************************************* */ private void setAttributes(RegionAttributes attrs, String regionName, InternalRegionArguments internalRegionArgs) { this.dataPolicy = attrs.getDataPolicy(); // do this one first @@ -1562,10 +1582,10 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib // fix bug #52033 by invoking setOffHeap now (localMaxMemory may now be the temporary // placeholder for off-heap until DistributedSystem is created // found non-null PartitionAttributes and offHeap is true so let's setOffHeap on PA now - PartitionAttributes pa = attrs.getPartitionAttributes(); - if (this.offHeap && pa != null) { - PartitionAttributesImpl impl = (PartitionAttributesImpl) pa; - impl.setOffHeap(this.offHeap); + PartitionAttributes partitionAttributes = attrs.getPartitionAttributes(); + if (this.offHeap && partitionAttributes != null) { + PartitionAttributesImpl impl = (PartitionAttributesImpl) partitionAttributes; + impl.setOffHeap(true); } this.evictionAttributes = @@ -1579,12 +1599,9 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib attrs.getPartitionAttributes().getLocalMaxMemory()})); this.evictionAttributes.setMaximum(attrs.getPartitionAttributes().getLocalMaxMemory()); } - // final boolean isNotPartitionedRegion = !(attrs.getPartitionAttributes() != null || attrs - // .getDataPolicy().withPartitioning()); - // if (isNotPartitionedRegion && this.evictionAttributes != null if (this.evictionAttributes != null && !this.evictionAttributes.getAlgorithm().isNone()) { - this.setEvictionController( + setEvictionController( this.evictionAttributes.createEvictionController(this, attrs.getOffHeap())); } storeCacheListenersField(attrs.getCacheListeners()); @@ -1595,14 +1612,14 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib setRegionTimeToLiveAtts(); this.regionIdleTimeout = attrs.getRegionIdleTimeout().getTimeout(); this.regionIdleTimeoutExpirationAction = attrs.getRegionIdleTimeout().getAction(); - setRegionIdleTimeoutAtts(); + setRegionIdleTimeoutAttributes(); this.entryTimeToLive = attrs.getEntryTimeToLive().getTimeout(); this.entryTimeToLiveExpirationAction = attrs.getEntryTimeToLive().getAction(); - setEntryTimeToLiveAtts(); + setEntryTimeToLiveAttributes(); this.customEntryTimeToLive = attrs.getCustomEntryTimeToLive(); this.entryIdleTimeout = attrs.getEntryIdleTimeout().getTimeout(); this.entryIdleTimeoutExpirationAction = attrs.getEntryIdleTimeout().getAction(); - setEntryIdleTimeoutAtts(); + setEntryIdleTimeoutAttributes(); this.customEntryIdleTimeout = attrs.getCustomEntryIdleTimeout(); updateEntryExpiryPossible(); this.statisticsEnabled = attrs.getStatisticsEnabled(); @@ -1680,45 +1697,49 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return result; } - public boolean existsValue(String predicate) throws FunctionDomainException, + @Override + public boolean existsValue(String queryPredicate) throws FunctionDomainException, TypeMismatchException, NameResolutionException, QueryInvocationTargetException { - return !query(predicate).isEmpty(); + return !query(queryPredicate).isEmpty(); } - public Object selectValue(String predicate) throws FunctionDomainException, TypeMismatchException, - NameResolutionException, QueryInvocationTargetException { - SelectResults result = query(predicate); + @Override + public Object selectValue(String queryPredicate) throws FunctionDomainException, + TypeMismatchException, NameResolutionException, QueryInvocationTargetException { + SelectResults result = query(queryPredicate); if (result.isEmpty()) { return null; } if (result.size() > 1) throw new FunctionDomainException( LocalizedStrings.AbstractRegion_SELECTVALUE_EXPECTS_RESULTS_OF_SIZE_1_BUT_FOUND_RESULTS_OF_SIZE_0 - .toLocalizedString(Integer.valueOf(result.size()))); + .toLocalizedString(result.size())); return result.iterator().next(); } + @Override public Set entrySet(boolean recursive) { return entries(recursive); } public abstract Set entries(boolean recursive); + @Override public EvictionAttributes getEvictionAttributes() { return this.evictionAttributes; } + @Override public EvictionAttributesMutator getEvictionAttributesMutator() { return this.evictionAttributes; } - - public void setEvictionController(LRUAlgorithm evictionController) { + private void setEvictionController(LRUAlgorithm evictionController) { this.evictionController = evictionController; } public LRUAlgorithm getEvictionController() { - return evictionController; + return this.evictionController; } /** @@ -1726,7 +1747,9 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * * @throws RegionAccessException if required roles are missing and the LossAction is NO_ACCESS */ - protected void checkForNoAccess() {} + protected void checkForNoAccess() { + // nothing + } /** * Throws RegionAccessException is required roles are missing and the LossAction is either @@ -1735,7 +1758,9 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib * @throws RegionAccessException if required roles are missing and the LossAction is either * NO_ACCESS or LIMITED_ACCESS */ - protected void checkForLimitedOrNoAccess() {} + protected void checkForLimitedOrNoAccess() { + // nothing + } /** * Makes sure that the data was distributed to every required role. If it was not it either queues @@ -1756,7 +1781,6 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return false; } - /** * Returns the serial number which identifies the static order in which this region was created in * relation to other regions or other instances of this region during the life of this JVM. @@ -1765,7 +1789,8 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return this.serialNumber; } - public /* final */ GemFireCacheImpl getCache() { + @Override + public InternalCache getCache() { return this.cache; } @@ -1773,11 +1798,12 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return this.cache.getInternalDistributedSystem().getClock().cacheTimeMillis(); } - public final RegionService getRegionService() { + @Override + public RegionService getRegionService() { return this.cache; } - public final DM getDistributionManager() { + public DM getDistributionManager() { return getSystem().getDistributionManager(); } @@ -1785,49 +1811,53 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib return getCache().getInternalDistributedSystem(); } - // DataSerializableFixedID support - public final int getDSFID() { + @Override + public int getDSFID() { return REGION; } - // DataSerializableFixedID support - public final void toData(DataOutput out) throws IOException { + @Override + public void toData(DataOutput out) throws IOException { DataSerializer.writeRegion(this, out); } - // DataSerializableFixedID support + @Override public void fromData(DataInput in) throws IOException, ClassNotFoundException { // should never be called since the special DataSerializer.readRegion is used. - throw new UnsupportedOperationException(); + throw new UnsupportedOperationException("fromData is not implemented"); } public boolean forceCompaction() { - throw new UnsupportedOperationException(); + throw new UnsupportedOperationException("forceCompaction is not implemented"); } + @Override public boolean getCloningEnabled() { return this.cloningEnable; } + @Override public void setCloningEnabled(boolean cloningEnable) { this.cloningEnable = cloningEnable; } - protected static Object handleNotAvailable(Object v) { - if (v == Token.NOT_AVAILABLE) { - v = null; + static Object handleNotAvailable(Object object) { + if (object == Token.NOT_AVAILABLE) { + object = null; } - return v; + return object; } - public GemFireCacheImpl getGemFireCache() { + public InternalCache getGemFireCache() { return this.cache; } + @Override public RegionSnapshotService getSnapshotService() { return new RegionSnapshotServiceImpl(this); } + @Override public Compressor getCompressor() { return this.compressor; } @@ -1837,9 +1867,10 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib */ @Override public ExtensionPoint> getExtensionPoint() { - return extensionPoint; + return this.extensionPoint; } + @Override public boolean getOffHeap() { return this.offHeap; }