geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kl...@apache.org
Subject [geode] branch develop updated: GEODE-3870: clean up region entry classes (#989)
Date Fri, 03 Nov 2017 16:04:35 GMT
This is an automated email from the ASF dual-hosted git repository.

klund pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git


The following commit(s) were added to refs/heads/develop by this push:
     new 9829873  GEODE-3870: clean up region entry classes (#989)
9829873 is described below

commit 9829873a4fb63d453fe8fe55750cd5d51ecaf8f9
Author: Kirk Lund <klund@apache.org>
AuthorDate: Fri Nov 3 09:04:33 2017 -0700

    GEODE-3870: clean up region entry classes (#989)
    
    * cleanup variable names and types
    * fix formatting and white space
    * add @Override annotations and fix parameter names
    * use interfaces instead of concrete implementations
    * move member variables and constants to the top
---
 .../geode/internal/cache/AbstractLRURegionMap.java |   2 +-
 .../geode/internal/cache/AbstractRegion.java       |  11 +-
 .../geode/internal/cache/AbstractRegionMap.java    |  68 +-
 .../apache/geode/internal/cache/BucketRegion.java  |   3 +-
 .../apache/geode/internal/cache/DiskRegion.java    |   4 +-
 .../apache/geode/internal/cache/DiskStoreImpl.java |  37 +-
 .../geode/internal/cache/EntryEventImpl.java       |   8 +-
 .../geode/internal/cache/HasCachePerfStats.java    |   3 +-
 .../{HasCachePerfStats.java => HasDiskRegion.java} |   5 +-
 .../geode/internal/cache/InternalRegion.java       |  77 ++-
 .../apache/geode/internal/cache/LocalRegion.java   |  38 +-
 .../geode/internal/cache/NonLocalRegionEntry.java  | 216 +++----
 .../org/apache/geode/internal/cache/Oplog.java     | 196 +++---
 .../org/apache/geode/internal/cache/OplogSet.java  |   6 +-
 .../geode/internal/cache/OverflowOplogSet.java     |  60 +-
 .../geode/internal/cache/PartitionedRegion.java    |   2 +-
 .../geode/internal/cache/PersistentOplogSet.java   |   9 +-
 .../geode/internal/cache/ProxyRegionMap.java       | 219 ++++---
 .../apache/geode/internal/cache/RegionEntry.java   |  82 +--
 .../org/apache/geode/internal/cache/RegionMap.java | 122 ++--
 .../geode/internal/cache/ValidatingDiskRegion.java | 150 ++---
 .../cache/entries/AbstractDiskRegionEntry.java     |   2 +-
 .../entries/AbstractOplogDiskRegionEntry.java      |  47 +-
 .../cache/entries/AbstractRegionEntry.java         | 127 ++--
 .../geode/internal/cache/entries/DiskEntry.java    | 101 +--
 .../internal/cache/entries/LeafRegionEntry.cpp     | 698 ++++++++++++---------
 .../VMStatsDiskLRURegionEntryHeapIntKey.java       | 232 +++----
 .../VMStatsDiskLRURegionEntryHeapLongKey.java      | 232 +++----
 .../VMStatsDiskLRURegionEntryHeapObjectKey.java    | 233 +++----
 .../VMStatsDiskLRURegionEntryHeapStringKey1.java   | 295 ++++-----
 .../VMStatsDiskLRURegionEntryHeapStringKey2.java   | 345 +++++-----
 .../VMStatsDiskLRURegionEntryHeapUUIDKey.java      | 234 +++----
 .../VMStatsDiskLRURegionEntryOffHeapIntKey.java    | 269 ++++----
 .../VMStatsDiskLRURegionEntryOffHeapLongKey.java   | 269 ++++----
 .../VMStatsDiskLRURegionEntryOffHeapObjectKey.java | 262 ++++----
 ...VMStatsDiskLRURegionEntryOffHeapStringKey1.java | 342 +++++-----
 ...VMStatsDiskLRURegionEntryOffHeapStringKey2.java | 392 ++++++------
 .../VMStatsDiskLRURegionEntryOffHeapUUIDKey.java   | 273 ++++----
 .../entries/VMStatsDiskRegionEntryHeapIntKey.java  | 175 +++---
 .../entries/VMStatsDiskRegionEntryHeapLongKey.java | 175 +++---
 .../VMStatsDiskRegionEntryHeapObjectKey.java       | 169 +++--
 .../VMStatsDiskRegionEntryHeapStringKey1.java      | 232 ++++---
 .../VMStatsDiskRegionEntryHeapStringKey2.java      | 282 +++++----
 .../entries/VMStatsDiskRegionEntryHeapUUIDKey.java | 177 +++---
 .../VMStatsDiskRegionEntryOffHeapIntKey.java       | 206 +++---
 .../VMStatsDiskRegionEntryOffHeapLongKey.java      | 206 +++---
 .../VMStatsDiskRegionEntryOffHeapObjectKey.java    | 206 +++---
 .../VMStatsDiskRegionEntryOffHeapStringKey1.java   | 284 +++++----
 .../VMStatsDiskRegionEntryOffHeapStringKey2.java   | 334 +++++-----
 .../VMStatsDiskRegionEntryOffHeapUUIDKey.java      | 210 +++----
 .../entries/VMStatsLRURegionEntryHeapIntKey.java   | 174 ++---
 .../entries/VMStatsLRURegionEntryHeapLongKey.java  | 174 ++---
 .../VMStatsLRURegionEntryHeapObjectKey.java        | 168 ++---
 .../VMStatsLRURegionEntryHeapStringKey1.java       | 231 +++----
 .../VMStatsLRURegionEntryHeapStringKey2.java       | 281 +++++----
 .../entries/VMStatsLRURegionEntryHeapUUIDKey.java  | 176 +++---
 .../VMStatsLRURegionEntryOffHeapIntKey.java        | 202 +++---
 .../VMStatsLRURegionEntryOffHeapLongKey.java       | 203 +++---
 .../VMStatsLRURegionEntryOffHeapObjectKey.java     | 201 +++---
 .../VMStatsLRURegionEntryOffHeapStringKey1.java    | 283 +++++----
 .../VMStatsLRURegionEntryOffHeapStringKey2.java    | 333 +++++-----
 .../VMStatsLRURegionEntryOffHeapUUIDKey.java       | 207 +++---
 .../entries/VMStatsRegionEntryHeapIntKey.java      | 132 ++--
 .../entries/VMStatsRegionEntryHeapLongKey.java     | 132 ++--
 .../entries/VMStatsRegionEntryHeapObjectKey.java   | 126 ++--
 .../entries/VMStatsRegionEntryHeapStringKey1.java  | 189 +++---
 .../entries/VMStatsRegionEntryHeapStringKey2.java  | 239 ++++---
 .../entries/VMStatsRegionEntryHeapUUIDKey.java     | 134 ++--
 .../entries/VMStatsRegionEntryOffHeapIntKey.java   | 160 +++--
 .../entries/VMStatsRegionEntryOffHeapLongKey.java  | 160 +++--
 .../VMStatsRegionEntryOffHeapObjectKey.java        | 154 +++--
 .../VMStatsRegionEntryOffHeapStringKey1.java       | 235 ++++---
 .../VMStatsRegionEntryOffHeapStringKey2.java       | 285 ++++-----
 .../entries/VMStatsRegionEntryOffHeapUUIDKey.java  | 164 +++--
 .../VMThinDiskLRURegionEntryHeapIntKey.java        | 192 +++---
 .../VMThinDiskLRURegionEntryHeapLongKey.java       | 192 +++---
 .../VMThinDiskLRURegionEntryHeapObjectKey.java     | 189 +++---
 .../VMThinDiskLRURegionEntryHeapStringKey1.java    | 251 ++++----
 .../VMThinDiskLRURegionEntryHeapStringKey2.java    | 301 ++++-----
 .../VMThinDiskLRURegionEntryHeapUUIDKey.java       | 194 +++---
 .../VMThinDiskLRURegionEntryOffHeapIntKey.java     | 225 +++----
 .../VMThinDiskLRURegionEntryOffHeapLongKey.java    | 225 +++----
 .../VMThinDiskLRURegionEntryOffHeapObjectKey.java  | 218 +++----
 .../VMThinDiskLRURegionEntryOffHeapStringKey1.java | 298 ++++-----
 .../VMThinDiskLRURegionEntryOffHeapStringKey2.java | 348 +++++-----
 .../VMThinDiskLRURegionEntryOffHeapUUIDKey.java    | 229 +++----
 .../entries/VMThinDiskRegionEntryHeapIntKey.java   | 135 ++--
 .../entries/VMThinDiskRegionEntryHeapLongKey.java  | 135 ++--
 .../VMThinDiskRegionEntryHeapObjectKey.java        | 129 ++--
 .../VMThinDiskRegionEntryHeapStringKey1.java       | 192 +++---
 .../VMThinDiskRegionEntryHeapStringKey2.java       | 242 ++++---
 .../entries/VMThinDiskRegionEntryHeapUUIDKey.java  | 137 ++--
 .../VMThinDiskRegionEntryOffHeapIntKey.java        | 165 +++--
 .../VMThinDiskRegionEntryOffHeapLongKey.java       | 166 +++--
 .../VMThinDiskRegionEntryOffHeapObjectKey.java     | 162 +++--
 .../VMThinDiskRegionEntryOffHeapStringKey1.java    | 240 ++++---
 .../VMThinDiskRegionEntryOffHeapStringKey2.java    | 290 ++++-----
 .../VMThinDiskRegionEntryOffHeapUUIDKey.java       | 170 +++--
 .../entries/VMThinLRURegionEntryHeapIntKey.java    | 134 ++--
 .../entries/VMThinLRURegionEntryHeapLongKey.java   | 134 ++--
 .../entries/VMThinLRURegionEntryHeapObjectKey.java | 128 ++--
 .../VMThinLRURegionEntryHeapStringKey1.java        | 191 +++---
 .../VMThinLRURegionEntryHeapStringKey2.java        | 241 +++----
 .../entries/VMThinLRURegionEntryHeapUUIDKey.java   | 136 ++--
 .../entries/VMThinLRURegionEntryOffHeapIntKey.java | 162 ++---
 .../VMThinLRURegionEntryOffHeapLongKey.java        | 162 ++---
 .../VMThinLRURegionEntryOffHeapObjectKey.java      | 157 ++---
 .../VMThinLRURegionEntryOffHeapStringKey1.java     | 239 +++----
 .../VMThinLRURegionEntryOffHeapStringKey2.java     | 289 +++++----
 .../VMThinLRURegionEntryOffHeapUUIDKey.java        | 166 ++---
 .../cache/entries/VMThinRegionEntryHeapIntKey.java |  92 ++-
 .../entries/VMThinRegionEntryHeapLongKey.java      |  92 ++-
 .../entries/VMThinRegionEntryHeapObjectKey.java    |  86 ++-
 .../entries/VMThinRegionEntryHeapStringKey1.java   | 149 +++--
 .../entries/VMThinRegionEntryHeapStringKey2.java   | 199 +++---
 .../entries/VMThinRegionEntryHeapUUIDKey.java      |  94 ++-
 .../entries/VMThinRegionEntryOffHeapIntKey.java    | 120 ++--
 .../entries/VMThinRegionEntryOffHeapLongKey.java   | 120 ++--
 .../entries/VMThinRegionEntryOffHeapObjectKey.java | 114 ++--
 .../VMThinRegionEntryOffHeapStringKey1.java        | 194 +++---
 .../VMThinRegionEntryOffHeapStringKey2.java        | 244 +++----
 .../entries/VMThinRegionEntryOffHeapUUIDKey.java   | 124 ++--
 ...VersionedStatsDiskLRURegionEntryHeapIntKey.java | 319 +++++-----
 ...ersionedStatsDiskLRURegionEntryHeapLongKey.java | 319 +++++-----
 ...sionedStatsDiskLRURegionEntryHeapObjectKey.java | 313 ++++-----
 ...ionedStatsDiskLRURegionEntryHeapStringKey1.java | 375 +++++------
 ...ionedStatsDiskLRURegionEntryHeapStringKey2.java | 425 +++++++------
 ...ersionedStatsDiskLRURegionEntryHeapUUIDKey.java | 321 +++++-----
 ...sionedStatsDiskLRURegionEntryOffHeapIntKey.java | 348 +++++-----
 ...ionedStatsDiskLRURegionEntryOffHeapLongKey.java | 348 +++++-----
 ...nedStatsDiskLRURegionEntryOffHeapObjectKey.java | 342 +++++-----
 ...edStatsDiskLRURegionEntryOffHeapStringKey1.java | 422 +++++++------
 ...edStatsDiskLRURegionEntryOffHeapStringKey2.java | 472 +++++++-------
 ...ionedStatsDiskLRURegionEntryOffHeapUUIDKey.java | 352 ++++++-----
 .../VersionedStatsDiskRegionEntryHeapIntKey.java   | 262 ++++----
 .../VersionedStatsDiskRegionEntryHeapLongKey.java  | 262 ++++----
 ...VersionedStatsDiskRegionEntryHeapObjectKey.java | 256 ++++----
 ...ersionedStatsDiskRegionEntryHeapStringKey1.java | 318 +++++-----
 ...ersionedStatsDiskRegionEntryHeapStringKey2.java | 368 +++++------
 .../VersionedStatsDiskRegionEntryHeapUUIDKey.java  | 264 ++++----
 ...VersionedStatsDiskRegionEntryOffHeapIntKey.java | 291 ++++-----
 ...ersionedStatsDiskRegionEntryOffHeapLongKey.java | 291 ++++-----
 ...sionedStatsDiskRegionEntryOffHeapObjectKey.java | 285 +++++----
 ...ionedStatsDiskRegionEntryOffHeapStringKey1.java | 365 +++++------
 ...ionedStatsDiskRegionEntryOffHeapStringKey2.java | 415 ++++++------
 ...ersionedStatsDiskRegionEntryOffHeapUUIDKey.java | 295 ++++-----
 .../VersionedStatsLRURegionEntryHeapIntKey.java    | 260 ++++----
 .../VersionedStatsLRURegionEntryHeapLongKey.java   | 261 ++++----
 .../VersionedStatsLRURegionEntryHeapObjectKey.java | 255 ++++----
 ...VersionedStatsLRURegionEntryHeapStringKey1.java | 317 +++++-----
 ...VersionedStatsLRURegionEntryHeapStringKey2.java | 367 ++++++-----
 .../VersionedStatsLRURegionEntryHeapUUIDKey.java   | 263 ++++----
 .../VersionedStatsLRURegionEntryOffHeapIntKey.java | 288 +++++----
 ...VersionedStatsLRURegionEntryOffHeapLongKey.java | 288 +++++----
 ...rsionedStatsLRURegionEntryOffHeapObjectKey.java | 282 +++++----
 ...sionedStatsLRURegionEntryOffHeapStringKey1.java | 362 ++++++-----
 ...sionedStatsLRURegionEntryOffHeapStringKey2.java | 414 ++++++------
 ...VersionedStatsLRURegionEntryOffHeapUUIDKey.java | 292 +++++----
 .../VersionedStatsRegionEntryHeapIntKey.java       | 212 ++++---
 .../VersionedStatsRegionEntryHeapLongKey.java      | 212 ++++---
 .../VersionedStatsRegionEntryHeapObjectKey.java    | 213 ++++---
 .../VersionedStatsRegionEntryHeapStringKey1.java   | 275 ++++----
 .../VersionedStatsRegionEntryHeapStringKey2.java   | 325 +++++-----
 .../VersionedStatsRegionEntryHeapUUIDKey.java      | 214 ++++---
 .../VersionedStatsRegionEntryOffHeapIntKey.java    | 247 ++++----
 .../VersionedStatsRegionEntryOffHeapLongKey.java   | 247 ++++----
 .../VersionedStatsRegionEntryOffHeapObjectKey.java | 240 +++----
 ...VersionedStatsRegionEntryOffHeapStringKey1.java | 320 +++++-----
 ...VersionedStatsRegionEntryOffHeapStringKey2.java | 372 +++++------
 .../VersionedStatsRegionEntryOffHeapUUIDKey.java   | 251 ++++----
 .../VersionedThinDiskLRURegionEntryHeapIntKey.java | 275 ++++----
 ...VersionedThinDiskLRURegionEntryHeapLongKey.java | 275 ++++----
 ...rsionedThinDiskLRURegionEntryHeapObjectKey.java | 269 ++++----
 ...sionedThinDiskLRURegionEntryHeapStringKey1.java | 331 +++++-----
 ...sionedThinDiskLRURegionEntryHeapStringKey2.java | 381 +++++------
 ...VersionedThinDiskLRURegionEntryHeapUUIDKey.java | 277 ++++----
 ...rsionedThinDiskLRURegionEntryOffHeapIntKey.java | 304 ++++-----
 ...sionedThinDiskLRURegionEntryOffHeapLongKey.java | 304 ++++-----
 ...onedThinDiskLRURegionEntryOffHeapObjectKey.java | 298 +++++----
 ...nedThinDiskLRURegionEntryOffHeapStringKey1.java | 378 +++++------
 ...nedThinDiskLRURegionEntryOffHeapStringKey2.java | 428 +++++++------
 ...sionedThinDiskLRURegionEntryOffHeapUUIDKey.java | 308 ++++-----
 .../VersionedThinDiskRegionEntryHeapIntKey.java    | 217 ++++---
 .../VersionedThinDiskRegionEntryHeapLongKey.java   | 218 +++----
 .../VersionedThinDiskRegionEntryHeapObjectKey.java | 212 ++++---
 ...VersionedThinDiskRegionEntryHeapStringKey1.java | 274 ++++----
 ...VersionedThinDiskRegionEntryHeapStringKey2.java | 324 +++++-----
 .../VersionedThinDiskRegionEntryHeapUUIDKey.java   | 220 +++----
 .../VersionedThinDiskRegionEntryOffHeapIntKey.java | 247 ++++----
 ...VersionedThinDiskRegionEntryOffHeapLongKey.java | 247 ++++----
 ...rsionedThinDiskRegionEntryOffHeapObjectKey.java | 241 +++----
 ...sionedThinDiskRegionEntryOffHeapStringKey1.java | 321 +++++-----
 ...sionedThinDiskRegionEntryOffHeapStringKey2.java | 371 +++++------
 ...VersionedThinDiskRegionEntryOffHeapUUIDKey.java | 251 ++++----
 .../VersionedThinLRURegionEntryHeapIntKey.java     | 216 ++++---
 .../VersionedThinLRURegionEntryHeapLongKey.java    | 217 ++++---
 .../VersionedThinLRURegionEntryHeapObjectKey.java  | 211 ++++---
 .../VersionedThinLRURegionEntryHeapStringKey1.java | 273 ++++----
 .../VersionedThinLRURegionEntryHeapStringKey2.java | 323 +++++-----
 .../VersionedThinLRURegionEntryHeapUUIDKey.java    | 219 ++++---
 .../VersionedThinLRURegionEntryOffHeapIntKey.java  | 244 +++----
 .../VersionedThinLRURegionEntryOffHeapLongKey.java | 244 +++----
 ...ersionedThinLRURegionEntryOffHeapObjectKey.java | 238 +++----
 ...rsionedThinLRURegionEntryOffHeapStringKey1.java | 318 +++++-----
 ...rsionedThinLRURegionEntryOffHeapStringKey2.java | 370 ++++++-----
 .../VersionedThinLRURegionEntryOffHeapUUIDKey.java | 248 ++++----
 .../VersionedThinRegionEntryHeapIntKey.java        | 172 ++---
 .../VersionedThinRegionEntryHeapLongKey.java       | 172 ++---
 .../VersionedThinRegionEntryHeapObjectKey.java     | 169 ++---
 .../VersionedThinRegionEntryHeapStringKey1.java    | 231 +++----
 .../VersionedThinRegionEntryHeapStringKey2.java    | 281 +++++----
 .../VersionedThinRegionEntryHeapUUIDKey.java       | 174 ++---
 .../VersionedThinRegionEntryOffHeapIntKey.java     | 203 +++---
 .../VersionedThinRegionEntryOffHeapLongKey.java    | 203 +++---
 .../VersionedThinRegionEntryOffHeapObjectKey.java  | 196 +++---
 .../VersionedThinRegionEntryOffHeapStringKey1.java | 276 ++++----
 .../VersionedThinRegionEntryOffHeapStringKey2.java | 328 +++++-----
 .../VersionedThinRegionEntryOffHeapUUIDKey.java    | 207 +++---
 .../apache/geode/internal/cache/lru/LRUEntry.java  |   6 +-
 .../geode/internal/cache/partitioned/Bucket.java   |   6 +-
 .../cache/partitioned/FetchEntriesMessage.java     |   2 +-
 .../cache/persistence/DiskRecoveryStore.java       |   1 -
 .../internal/cache/tier/sockets/BaseCommand.java   |   2 +-
 .../internal/cache/versions/VersionSource.java     |   6 +-
 .../internal/cache/versions/VersionStamp.java      |  42 +-
 .../internal/offheap/MemoryAllocatorImpl.java      |   2 +-
 .../concurrent/CustomEntryConcurrentHashMap.java   |   4 +-
 .../geode/cache30/MultiVMRegionTestCase.java       |   6 +-
 .../internal/cache/AbstractRegionJUnitTest.java    | 134 ++++
 .../geode/internal/cache/Bug37377DUnitTest.java    |   4 +-
 .../geode/internal/cache/DiskRegionJUnitTest.java  | 113 ++--
 .../internal/cache/PRDataStoreMemoryJUnitTest.java |   6 +-
 .../internal/cache/RemoteTransactionDUnitTest.java |   2 +-
 .../cache/partitioned/Bug43684DUnitTest.java       |   2 +-
 .../offheap/OffHeapValidationJUnitTest.java        |   2 +-
 235 files changed, 25981 insertions(+), 23730 deletions(-)

diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractLRURegionMap.java b/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractLRURegionMap.java
index 8e63dd4..622f746 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractLRURegionMap.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractLRURegionMap.java
@@ -182,7 +182,7 @@ public abstract class AbstractLRURegionMap extends AbstractRegionMap {
         // no need to worry about the value changing form with entry LRU.
         return false;
       }
-      Object curVal = le._getValue(); // OFFHEAP: _getValue ok
+      Object curVal = le.getValue(); // OFFHEAP: _getValue ok
       if (curVal != cd) {
         if (cd instanceof StoredObject) {
           if (!cd.equals(curVal)) {
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 e6fdaaf..bc97a35 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
@@ -98,8 +98,8 @@ import org.apache.geode.pdx.internal.PeerTypeRegistration;
  * 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<Region<?, ?>> {
+public abstract class AbstractRegion implements InternalRegion, AttributesMutator, CacheStatistics,
+    DataSerializableFixedID, Extensible<Region<?, ?>> {
 
   private static final Logger logger = LogService.getLogger();
 
@@ -428,8 +428,6 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib
 
   abstract Map basicGetAll(Collection keys, Object callback);
 
-  public abstract RegionEntry basicGetEntry(Object key);
-
   protected StringBuilder getStringBuilder() {
     StringBuilder buf = new StringBuilder();
     buf.append(getClass().getName());
@@ -808,6 +806,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib
   /**
    * Get IndexManger for region
    */
+  @Override
   public IndexManager getIndexManager() {
     return this.indexManager;
   }
@@ -845,6 +844,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib
   // block
   // in case the value of the entry is "REMOVED" token. This prevents dead lock
   // caused by the Bug # 33336
+  @Override
   public boolean isIndexCreationThread() {
     Boolean value = isIndexCreator.get();
     return value != null ? value : false;
@@ -1473,6 +1473,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib
    *
    * @since GemFire 5.0
    */
+  @Override
   public boolean isProxy() {
     return getDataPolicy().isEmpty();
   }
@@ -1515,6 +1516,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib
   /**
    * Returns true if this region could expire an entry
    */
+  @Override
   public boolean isEntryExpiryPossible() {
     return this.entryExpiryPossible;
   }
@@ -1760,6 +1762,7 @@ public abstract class AbstractRegion implements Region, RegionAttributes, Attrib
     return this.cache;
   }
 
+  @Override
   public DM getDistributionManager() {
     return getSystem().getDistributionManager();
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractRegionMap.java b/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractRegionMap.java
index 52d6e62..6ea53be 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractRegionMap.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractRegionMap.java
@@ -150,6 +150,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     }
   }
 
+  @Override
   public void changeOwner(LocalRegion r) {
     if (r == _getOwnerObject()) {
       return;
@@ -162,6 +163,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     this.entryFactory = f;
   }
 
+  @Override
   public RegionEntryFactory getEntryFactory() {
     return this.entryFactory;
   }
@@ -170,6 +172,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     this.attr = a;
   }
 
+  @Override
   public Attributes getAttributes() {
     return this.attr;
   }
@@ -186,6 +189,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     return this.owner;
   }
 
+  @Override
   public void setOwner(Object r) {
     this.owner = r;
   }
@@ -198,6 +202,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     this.map = m;
   }
 
+  @Override
   public int size() {
     return _getMap().size();
   }
@@ -208,14 +213,17 @@ public abstract class AbstractRegionMap implements RegionMap {
     return _getMap().size();
   }
 
+  @Override
   public boolean isEmpty() {
     return _getMap().isEmpty();
   }
 
+  @Override
   public Set keySet() {
     return _getMap().keySet();
   }
 
+  @Override
   @SuppressWarnings({"unchecked", "rawtypes"})
   public Collection<RegionEntry> regionEntries() {
     return (Collection) _getMap().values();
@@ -227,6 +235,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     return (Collection) _getMap().values();
   }
 
+  @Override
   public boolean containsKey(Object key) {
     RegionEntry re = getEntry(key);
     if (re == null) {
@@ -238,6 +247,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     return true;
   }
 
+  @Override
   public RegionEntry getEntry(Object key) {
     RegionEntry re = (RegionEntry) _getMap().get(key);
     return re;
@@ -254,12 +264,13 @@ public abstract class AbstractRegionMap implements RegionMap {
   }
 
 
+  @Override
   public RegionEntry putEntryIfAbsent(Object key, RegionEntry re) {
     RegionEntry oldRe = (RegionEntry) _getMap().putIfAbsent(key, re);
     if (oldRe == null && (re instanceof OffHeapRegionEntry) && _isOwnerALocalRegion()
         && _getOwner().isThisRegionBeingClosedOrDestroyed()) {
       // prevent orphan during concurrent destroy (#48068)
-      Object v = re._getValue();
+      Object v = re.getValue();
       if (v != Token.REMOVED_PHASE1 && v != Token.REMOVED_PHASE2 && v instanceof StoredObject
           && ((StoredObject) v).hasRefCount()) {
         if (_getMap().remove(key, re)) {
@@ -277,6 +288,7 @@ public abstract class AbstractRegionMap implements RegionMap {
   }
 
 
+  @Override
   public void removeEntry(Object key, RegionEntry re, boolean updateStat) {
     if (re.isTombstone() && _getMap().get(key) == re) {
       logger.fatal(
@@ -292,8 +304,9 @@ public abstract class AbstractRegionMap implements RegionMap {
     }
   }
 
+  @Override
   public void removeEntry(Object key, RegionEntry re, boolean updateStat, EntryEventImpl event,
-      final LocalRegion owner) {
+      final InternalRegion owner) {
     boolean success = false;
     if (re.isTombstone() && _getMap().get(key) == re) {
       logger.fatal(
@@ -333,11 +346,8 @@ public abstract class AbstractRegionMap implements RegionMap {
     _getMap().clear();
   }
 
+  @Override
   public void close() {
-    /*
-     * for (SuspectEntryList l: this.suspectEntries.values()) { for (EntryEventImpl e: l) {
-     * e.release(); } }
-     */
     clear(null);
   }
 
@@ -345,6 +355,7 @@ public abstract class AbstractRegionMap implements RegionMap {
    * Clear the region and, if an RVV is given, return a collection of the version sources in all
    * remaining tags
    */
+  @Override
   public Set<VersionSource> clear(RegionVersionVector rvv) {
     Set<VersionSource> result = new HashSet<VersionSource>();
 
@@ -408,7 +419,7 @@ public abstract class AbstractRegionMap implements RegionMap {
               // note: it.remove() did not reliably remove the entry so we use remove(K,V) here
               if (_getMap().remove(re.getKey(), re)) {
                 if (OffHeapRegionEntryHelper.doesClearNeedToCheckForOffHeap()) {
-                  GatewaySenderEventImpl.release(re._getValue()); // OFFHEAP _getValue ok
+                  GatewaySenderEventImpl.release(re.getValue()); // OFFHEAP _getValue ok
                 }
                 // If this is an overflow only region, we need to free the entry on
                 // disk at this point.
@@ -445,6 +456,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     return result;
   }
 
+  @Override
   public void lruUpdateCallback() {
     // By default do nothing; LRU maps needs to override this method
   }
@@ -453,19 +465,23 @@ public abstract class AbstractRegionMap implements RegionMap {
     // By default do nothing; LRU maps needs to override this method
   }
 
+  @Override
   public void lruUpdateCallback(int i) {
     // By default do nothing; LRU maps needs to override this method
   }
 
+  @Override
   public boolean disableLruUpdateCallback() {
     // By default do nothing; LRU maps needs to override this method
     return false;
   }
 
+  @Override
   public void enableLruUpdateCallback() {
     // By default do nothing; LRU maps needs to override this method
   }
 
+  @Override
   public void resetThreadLocals() {
     // By default do nothing; LRU maps needs to override this method
   }
@@ -505,10 +521,12 @@ public abstract class AbstractRegionMap implements RegionMap {
     return false;
   }
 
+  @Override
   public void lruCloseStats() {
     // do nothing by default
   }
 
+  @Override
   public void lruEntryFaultIn(LRUEntry entry) {
     // do nothing by default
   }
@@ -516,7 +534,7 @@ public abstract class AbstractRegionMap implements RegionMap {
   /**
    * Process an incoming version tag for concurrent operation detection. This must be done before
    * modifying the region entry.
-   * 
+   *
    * @param re the entry that is to be modified
    * @param event the modification to the entry
    * @throws InvalidDeltaException if the event contains a delta that cannot be applied
@@ -549,6 +567,7 @@ public abstract class AbstractRegionMap implements RegionMap {
         owner.getMyId(), sender, checkConflicts);
   }
 
+  @Override
   public void copyRecoveredEntries(RegionMap rm) {
     // We need to sort the tombstones before scheduling them,
     // so that they will be in the correct order.
@@ -566,7 +585,7 @@ public abstract class AbstractRegionMap implements RegionMap {
         @Retained
         @Released
         Object value = oldRe
-            ._getValueRetain((RegionEntryContext) ((AbstractRegionMap) rm)._getOwnerObject(), true);
+            .getValueRetain((RegionEntryContext) ((AbstractRegionMap) rm)._getOwnerObject(), true);
 
         try {
           if (value == Token.NOT_AVAILABLE) {
@@ -645,6 +664,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     _getMap().put(newRe.getKey(), newRe);
   }
 
+  @Override
   @Retained // Region entry may contain an off-heap value
   public RegionEntry initRecoveredEntry(Object key, DiskEntry.RecoveredEntry value) {
     boolean needsCallback = false;
@@ -702,6 +722,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     return newRe;
   }
 
+  @Override
   public RegionEntry updateRecoveredEntry(Object key, DiskEntry.RecoveredEntry value) {
     boolean needsCallback = false;
     RegionEntry re = getEntry(key);
@@ -761,6 +782,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     return re;
   }
 
+  @Override
   public boolean initialImagePut(final Object key, final long lastModified, Object newValue,
       final boolean wasRecovered, boolean deferLRUCallback, VersionTag entryVersion,
       InternalDistributedMember sender, boolean isSynchronizing) {
@@ -1036,6 +1058,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     return true;
   }
 
+  @Override
   public boolean destroy(EntryEventImpl event, boolean inTokenMode, boolean duringRI,
       boolean cacheWrite, boolean isEviction, Object expectedOldValue, boolean removeRecoveredEntry)
       throws CacheWriterException, EntryNotFoundException, TimeoutException {
@@ -1583,6 +1606,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     return tag;
   }
 
+  @Override
   public void txApplyDestroy(Object key, TransactionId txId, TXRmtEvent txEvent,
       boolean inTokenMode, boolean inRI, Operation op, EventID eventId, Object aCallbackArgument,
       List<EntryEventImpl> pendingCallbacks, FilterRoutingInfo filterRoutingInfo,
@@ -1886,6 +1910,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     }
   }
 
+  @Override
   public boolean invalidate(EntryEventImpl event, boolean invokeCallbacks, boolean forceNewEntry,
       boolean forceCallbacks) throws EntryNotFoundException {
     final boolean isDebugEnabled = logger.isDebugEnabled();
@@ -2313,7 +2338,7 @@ public abstract class AbstractRegionMap implements RegionMap {
 
   /*
    * (non-Javadoc)
-   * 
+   *
    * @see
    * org.apache.geode.internal.cache.RegionMap#updateEntryVersion(org.apache.geode.internal.cache.
    * EntryEventImpl)
@@ -2372,6 +2397,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     }
   }
 
+  @Override
   public void txApplyInvalidate(Object key, Object newValue, boolean didDestroy, TransactionId txId,
       TXRmtEvent txEvent, boolean localOp, EventID eventId, Object aCallbackArgument,
       List<EntryEventImpl> pendingCallbacks, FilterRoutingInfo filterRoutingInfo,
@@ -2629,6 +2655,7 @@ public abstract class AbstractRegionMap implements RegionMap {
    * This code needs to be evaluated. It was added quickly to help PR persistence not to consume as
    * much memory.
    */
+  @Override
   public void evictValue(Object key) {
     final LocalRegion owner = _getOwner();
     RegionEntry re = getEntry(key);
@@ -2679,6 +2706,7 @@ public abstract class AbstractRegionMap implements RegionMap {
   /*
    * returns null if the operation fails
    */
+  @Override
   public RegionEntry basicPut(EntryEventImpl event, final long lastModified, final boolean ifNew,
       final boolean ifOld, Object expectedOldValue, // only non-null if ifOld
       boolean requireOldValue, final boolean overwriteDestroyed)
@@ -2951,9 +2979,9 @@ public abstract class AbstractRegionMap implements RegionMap {
 
         @Retained
         @Released
-        Object oldValueInVM = re._getValueRetain(event.getLocalRegion(), true); // OFFHEAP: re
-                                                                                // synced so can use
-                                                                                // its ref.
+        Object oldValueInVM = re.getValueRetain(event.getLocalRegion(), true); // OFFHEAP: re
+                                                                               // synced so can use
+                                                                               // its ref.
 
         ReferenceCountHelper.unskipRefCountTracking();
         try {
@@ -2966,8 +2994,8 @@ public abstract class AbstractRegionMap implements RegionMap {
       // if the old value is in memory then if it is a GatewaySenderEventImpl then
       // we want to set the old value.
       @Unretained
-      Object ov = re._getValue(); // OFFHEAP _getValue is ok since re is synced and we only use it
-                                  // if its a GatewaySenderEventImpl.
+      Object ov = re.getValue(); // OFFHEAP _getValue is ok since re is synced and we only use it
+                                 // if its a GatewaySenderEventImpl.
       // Since GatewaySenderEventImpl is never stored in an off-heap region nor a compressed region
       // we don't need to worry about ov being compressed.
       if (ov instanceof GatewaySenderEventImpl) {
@@ -3106,6 +3134,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     return retVal;
   }
 
+  @Override
   public void txApplyPut(Operation p_putOp, Object key, Object nv, boolean didDestroy,
       TransactionId txId, TXRmtEvent txEvent, EventID eventId, Object aCallbackArgument,
       List<EntryEventImpl> pendingCallbacks, FilterRoutingInfo filterRoutingInfo,
@@ -3494,7 +3523,7 @@ public abstract class AbstractRegionMap implements RegionMap {
   /**
    * Removing the existing indexed value requires the current value in the cache, that is the one
    * prior to applying the operation.
-   * 
+   *
    * @param entry the RegionEntry that contains the value prior to applying the op
    */
   private void txRemoveOldIndexEntry(Operation op, RegionEntry entry) {
@@ -3640,6 +3669,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     }
   }
 
+  @Override
   public void writeSyncIfPresent(Object key, Runnable runner) {
     RegionEntry re = getEntry(key);
     if (re != null) {
@@ -3664,6 +3694,7 @@ public abstract class AbstractRegionMap implements RegionMap {
     }
   }
 
+  @Override
   public void removeIfDestroyed(Object key) {
     LocalRegion owner = _getOwner();
     // boolean makeTombstones = owner.concurrencyChecksEnabled;
@@ -3755,13 +3786,14 @@ public abstract class AbstractRegionMap implements RegionMap {
 
   /**
    * for testing race conditions between threads trying to apply ops to the same entry
-   * 
+   *
    * @param entry the entry to attempt to add to the system
    */
   protected RegionEntry putEntryIfAbsentForTest(RegionEntry entry) {
     return (RegionEntry) putEntryIfAbsent(entry.getKey(), entry);
   }
 
+  @Override
   public boolean isTombstoneNotNeeded(RegionEntry re, int destroyedVersion) {
     // no need for synchronization - stale values are okay here
     // TODO this looks like a problem for regionEntry pooling
@@ -3794,6 +3826,7 @@ public abstract class AbstractRegionMap implements RegionMap {
   }
 
   /** removes a tombstone that has expired locally */
+  @Override
   public boolean removeTombstone(RegionEntry re, VersionHolder version, boolean isEviction,
       boolean isScheduledTombstone) {
     boolean result = false;
@@ -3908,6 +3941,7 @@ public abstract class AbstractRegionMap implements RegionMap {
 
   private ARMLockTestHook armLockTestHook;
 
+  @Override
   public ARMLockTestHook getARMLockTestHook() {
     return armLockTestHook;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/BucketRegion.java b/geode-core/src/main/java/org/apache/geode/internal/cache/BucketRegion.java
index f744780..72de15b 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/BucketRegion.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/BucketRegion.java
@@ -1478,7 +1478,6 @@ public class BucketRegion extends DistributedRegion implements Bucket {
    * Horribly plagiarized from the similar method in LocalRegion
    * 
    * @param clientEvent holder for the entry's version information
-   * @param returnTombstones TODO
    * @return serialized (byte) form
    * @throws IOException if the result is not serializable
    * @see LocalRegion#get(Object, Object, boolean, EntryEventImpl)
@@ -2120,7 +2119,7 @@ public class BucketRegion extends DistributedRegion implements Bucket {
 
   @Override
   public int calculateRegionEntryValueSize(RegionEntry regionEntry) {
-    return calcMemSize(regionEntry._getValue()); // OFFHEAP _getValue ok
+    return calcMemSize(regionEntry.getValue()); // OFFHEAP _getValue ok
   }
 
   @Override
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/DiskRegion.java b/geode-core/src/main/java/org/apache/geode/internal/cache/DiskRegion.java
index f37db6b..7b8b17c 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/DiskRegion.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/DiskRegion.java
@@ -346,7 +346,7 @@ public class DiskRegion extends AbstractDiskRegion {
    *         completed successfully, resulting in the put operation to abort.
    * @throws IllegalArgumentException If <code>id</code> is less than zero
    */
-  public void put(DiskEntry entry, LocalRegion region, ValueWrapper value, boolean async)
+  public void put(DiskEntry entry, InternalRegion region, ValueWrapper value, boolean async)
       throws RegionClearedException {
     getDiskStore().put(region, entry, value, async);
   }
@@ -418,7 +418,7 @@ public class DiskRegion extends AbstractDiskRegion {
     getDiskStore().remove(region, entry, false, false);
   }
 
-  public void remove(LocalRegion region, DiskEntry entry, boolean async, boolean isClear)
+  public void remove(InternalRegion region, DiskEntry entry, boolean async, boolean isClear)
       throws RegionClearedException {
     getDiskStore().remove(region, entry, async, isClear);
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/DiskStoreImpl.java b/geode-core/src/main/java/org/apache/geode/internal/cache/DiskStoreImpl.java
index 6059b1c..86009dd 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/DiskStoreImpl.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/DiskStoreImpl.java
@@ -682,7 +682,7 @@ public class DiskStoreImpl implements DiskStore {
    *         completed successfully, resulting in the put operation to abort.
    * @throws IllegalArgumentException If {@code id} is less than zero
    */
-  void put(LocalRegion region, DiskEntry entry, ValueWrapper value, boolean async)
+  void put(InternalRegion region, DiskEntry entry, ValueWrapper value, boolean async)
       throws RegionClearedException {
     DiskRegion dr = region.getDiskRegion();
     DiskId id = entry.getDiskId();
@@ -750,7 +750,7 @@ public class DiskStoreImpl implements DiskStore {
     }
   }
 
-  public void putVersionTagOnly(LocalRegion region, VersionTag tag, boolean async) {
+  public void putVersionTagOnly(InternalRegion region, VersionTag tag, boolean async) {
     DiskRegion dr = region.getDiskRegion();
     // this method will only be called by backup oplog
     assert dr.isBackup();
@@ -1051,7 +1051,7 @@ public class DiskStoreImpl implements DiskStore {
    * @throws IllegalArgumentException If {@code id} is {@linkplain #INVALID_ID invalid}or is less
    *         than zero, no action is taken.
    */
-  void remove(LocalRegion region, DiskEntry entry, boolean async, boolean isClear)
+  void remove(InternalRegion region, DiskEntry entry, boolean async, boolean isClear)
       throws RegionClearedException {
     DiskRegion dr = region.getDiskRegion();
     if (!async) {
@@ -1240,7 +1240,7 @@ public class DiskStoreImpl implements DiskStore {
 
   private void handleFullAsyncQueue(Object o) {
     AsyncDiskEntry ade = (AsyncDiskEntry) o;
-    LocalRegion region = ade.region;
+    InternalRegion region = ade.region;
     try {
       VersionTag tag = ade.tag;
       if (ade.versionOnly) {
@@ -1275,7 +1275,7 @@ public class DiskStoreImpl implements DiskStore {
         if (dr.didClearCountChange() && !ade.versionOnly) {
           return;
         }
-        if (ade.region.isDestroyed) {
+        if (ade.region.isDestroyed()) {
           throw new RegionDestroyedException(ade.region.toString(), ade.region.getFullPath());
         }
       }
@@ -1708,7 +1708,7 @@ public class DiskStoreImpl implements DiskStore {
                     lr.getDiskRegion().writeRVVGC(lr);
                   } else {
                     AsyncDiskEntry ade = (AsyncDiskEntry) o;
-                    LocalRegion region = ade.region;
+                    InternalRegion region = ade.region;
                     VersionTag tag = ade.tag;
                     if (ade.versionOnly) {
                       DiskEntry.Helper.doAsyncFlush(tag, region);
@@ -3380,31 +3380,20 @@ public class DiskStoreImpl implements DiskStore {
     this.criticalPercent = criticalPercent;
   }
 
-  // public String toString() {
-  // StringBuffer sb = new StringBuffer();
-  // sb.append("<");
-  // sb.append(getName());
-  // if (getOwnedByRegion()) {
-  // sb.append(" OWNED_BY_REGION");
-  // }
-  // sb.append(">");
-  // return sb.toString();
-  // }
-
   public static class AsyncDiskEntry {
-    public final LocalRegion region;
+    public final InternalRegion region;
     public final DiskEntry de;
     public final boolean versionOnly;
     public final VersionTag tag;
 
-    public AsyncDiskEntry(LocalRegion region, DiskEntry de, VersionTag tag) {
+    public AsyncDiskEntry(InternalRegion region, DiskEntry de, VersionTag tag) {
       this.region = region;
       this.de = de;
       this.tag = tag;
       this.versionOnly = false;
     }
 
-    public AsyncDiskEntry(LocalRegion region, VersionTag tag) {
+    public AsyncDiskEntry(InternalRegion region, VersionTag tag) {
       this.region = region;
       this.de = null;
       this.tag = tag;
@@ -3623,7 +3612,7 @@ public class DiskStoreImpl implements DiskStore {
     ArrayList<Object> result = new ArrayList<>();
     Pattern pattern = createPdxRenamePattern(oldBase);
     for (RegionEntry re : foundPdx.getRecoveredEntryMap().regionEntries()) {
-      Object value = re._getValueRetain(foundPdx, true);
+      Object value = re.getValueRetain(foundPdx, true);
       if (Token.isRemoved(value)) {
         continue;
       }
@@ -3700,7 +3689,7 @@ public class DiskStoreImpl implements DiskStore {
     PersistentOplogSet oplogSet = (PersistentOplogSet) getOplogSet(foundPdx);
     ArrayList<PdxType> result = new ArrayList<PdxType>();
     for (RegionEntry re : foundPdx.getRecoveredEntryMap().regionEntries()) {
-      Object value = re._getValueRetain(foundPdx, true);
+      Object value = re.getValueRetain(foundPdx, true);
       if (Token.isRemoved(value)) {
         continue;
       }
@@ -3747,7 +3736,7 @@ public class DiskStoreImpl implements DiskStore {
     recoverRegionsThatAreReady();
     ArrayList<PdxType> result = new ArrayList<PdxType>();
     for (RegionEntry re : foundPdx.getRecoveredEntryMap().regionEntries()) {
-      Object value = re._getValueRetain(foundPdx, true);
+      Object value = re.getValueRetain(foundPdx, true);
       if (Token.isRemoved(value)) {
         continue;
       }
@@ -3789,7 +3778,7 @@ public class DiskStoreImpl implements DiskStore {
     recoverRegionsThatAreReady();
     ArrayList<Object> result = new ArrayList<Object>();
     for (RegionEntry re : foundPdx.getRecoveredEntryMap().regionEntries()) {
-      Object value = re._getValueRetain(foundPdx, true);
+      Object value = re.getValueRetain(foundPdx, true);
       if (Token.isRemoved(value)) {
         continue;
       }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/EntryEventImpl.java b/geode-core/src/main/java/org/apache/geode/internal/cache/EntryEventImpl.java
index e11b50d..599c76d 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/EntryEventImpl.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/EntryEventImpl.java
@@ -1501,10 +1501,10 @@ public class EntryEventImpl
           Object ov;
           if (ReferenceCountHelper.trackReferenceCounts()) {
             ReferenceCountHelper.setReferenceCountOwner(new OldValueOwner());
-            ov = reentry._getValueRetain(owner, true);
+            ov = reentry.getValueRetain(owner, true);
             ReferenceCountHelper.setReferenceCountOwner(null);
           } else {
-            ov = reentry._getValueRetain(owner, true);
+            ov = reentry.getValueRetain(owner, true);
           }
           if (ov == null)
             ov = Token.NOT_AVAILABLE;
@@ -1803,7 +1803,7 @@ public class EntryEventImpl
       if (re == null)
         return false;
       ReferenceCountHelper.skipRefCountTracking();
-      Object v = re._getValueRetain(this.region, true);
+      Object v = re.getValueRetain(this.region, true);
       ReferenceCountHelper.unskipRefCountTracking();
       try {
         return setOldValue(v);
@@ -2292,7 +2292,7 @@ public class EntryEventImpl
    * 
    * @param notifyGateways pass the event on to WAN queues
    */
-  public void invokeCallbacks(LocalRegion rgn, boolean skipListeners, boolean notifyGateways) {
+  public void invokeCallbacks(InternalRegion rgn, boolean skipListeners, boolean notifyGateways) {
     if (!callbacksInvoked()) {
       callbacksInvoked(true);
       if (this.op.isUpdate()) {
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/HasCachePerfStats.java b/geode-core/src/main/java/org/apache/geode/internal/cache/HasCachePerfStats.java
index 0aabb57..5235228 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/HasCachePerfStats.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/HasCachePerfStats.java
@@ -15,5 +15,6 @@
 package org.apache.geode.internal.cache;
 
 public interface HasCachePerfStats {
-  public CachePerfStats getCachePerfStats();
+
+  CachePerfStats getCachePerfStats();
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/HasCachePerfStats.java b/geode-core/src/main/java/org/apache/geode/internal/cache/HasDiskRegion.java
similarity index 91%
copy from geode-core/src/main/java/org/apache/geode/internal/cache/HasCachePerfStats.java
copy to geode-core/src/main/java/org/apache/geode/internal/cache/HasDiskRegion.java
index 0aabb57..b504b99 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/HasCachePerfStats.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/HasDiskRegion.java
@@ -14,6 +14,7 @@
  */
 package org.apache.geode.internal.cache;
 
-public interface HasCachePerfStats {
-  public CachePerfStats getCachePerfStats();
+public interface HasDiskRegion {
+
+  DiskRegion getDiskRegion();
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegion.java b/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegion.java
index 4af148c..3937666 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegion.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegion.java
@@ -14,8 +14,18 @@
  */
 package org.apache.geode.internal.cache;
 
+import org.apache.geode.CancelCriterion;
+import org.apache.geode.cache.CacheWriterException;
+import org.apache.geode.cache.EntryNotFoundException;
 import org.apache.geode.cache.Region;
+import org.apache.geode.cache.RegionAttributes;
+import org.apache.geode.cache.TimeoutException;
+import org.apache.geode.cache.client.internal.ServerRegionProxy;
+import org.apache.geode.cache.query.internal.index.IndexManager;
 import org.apache.geode.distributed.internal.DM;
+import org.apache.geode.internal.cache.versions.RegionVersionVector;
+import org.apache.geode.internal.cache.versions.VersionSource;
+import org.apache.geode.internal.cache.versions.VersionTag;
 
 /**
  * Interface to be used instead of type-casting to LocalRegion.
@@ -30,10 +40,10 @@ import org.apache.geode.distributed.internal.DM;
  * <li>DataSerializableFixedID
  * <li>RegionEntryContext
  * <li>Extensible
- * </pre>
  * </ul>
  */
-public interface InternalRegion<K, V> extends Region<K, V>, HasCachePerfStats {
+public interface InternalRegion<K, V>
+    extends Region<K, V>, HasCachePerfStats, RegionEntryContext, RegionAttributes, HasDiskRegion {
 
   CachePerfStats getCachePerfStats();
 
@@ -41,4 +51,67 @@ public interface InternalRegion<K, V> extends Region<K, V>, HasCachePerfStats {
 
   RegionEntry getRegionEntry(K key);
 
+  RegionVersionVector getVersionVector();
+
+  long cacheTimeMillis();
+
+  Object getValueInVM(Object key) throws EntryNotFoundException;
+
+  Object getValueOnDisk(Object key) throws EntryNotFoundException;
+
+  void dispatchListenerEvent(EnumListenerEvent op, InternalCacheEvent event);
+
+  boolean isUsedForPartitionedRegionAdmin();
+
+  ImageState getImageState();
+
+  VersionSource getVersionMember();
+
+  long updateStatsForPut(RegionEntry entry, long lastModified, boolean lruRecentUse);
+
+  FilterProfile getFilterProfile();
+
+  ServerRegionProxy getServerProxy();
+
+  void unscheduleTombstone(RegionEntry entry);
+
+  void scheduleTombstone(RegionEntry entry, VersionTag destroyedVersion);
+
+  boolean isEntryExpiryPossible();
+
+  void addExpiryTaskIfAbsent(RegionEntry entry);
+
+  DM getDistributionManager();
+
+  void generateAndSetVersionTag(InternalCacheEvent event, RegionEntry entry);
+
+  boolean cacheWriteBeforeDestroy(EntryEventImpl event, Object expectedOldValue)
+      throws CacheWriterException, EntryNotFoundException, TimeoutException;
+
+  void recordEvent(InternalCacheEvent event);
+
+  boolean isProxy();
+
+  IndexManager getIndexManager();
+
+  boolean isConcurrencyChecksEnabled();
+
+  boolean isThisRegionBeingClosedOrDestroyed();
+
+  CancelCriterion getCancelCriterion();
+
+  boolean isIndexCreationThread();
+
+  int updateSizeOnEvict(Object key, int oldSize);
+
+  RegionEntry basicGetEntry(Object key);
+
+  void invokePutCallbacks(final EnumListenerEvent eventType, final EntryEventImpl event,
+      final boolean callDispatchListenerEvent, boolean notifyGateways);
+
+  void invokeDestroyCallbacks(final EnumListenerEvent eventType, final EntryEventImpl event,
+      final boolean callDispatchListenerEvent, boolean notifyGateways);
+
+  void invokeInvalidateCallbacks(final EnumListenerEvent eventType, final EntryEventImpl event,
+      final boolean callDispatchListenerEvent);
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/LocalRegion.java b/geode-core/src/main/java/org/apache/geode/internal/cache/LocalRegion.java
index 7df7da2..58f3d51 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/LocalRegion.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/LocalRegion.java
@@ -536,6 +536,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
     return initializingRegion.get();
   }
 
+  @Override
   public CancelCriterion getCancelCriterion() {
     return this.stopper;
   }
@@ -690,6 +691,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
   }
 
   /** returns the regions version-vector */
+  @Override
   public RegionVersionVector getVersionVector() {
     return this.versionVector;
   }
@@ -779,6 +781,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
 
   private final InternalDataView sharedDataView;
 
+  @Override
   public ServerRegionProxy getServerProxy() {
     return this.serverRegionProxy;
   }
@@ -838,6 +841,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
     return this.cache.getInternalDistributedSystem().getDistributedMember();
   }
 
+  @Override
   public VersionSource getVersionMember() {
     if (this.dataPolicy.withPersistence()) {
       return getDiskStore().getDiskStoreID();
@@ -1797,6 +1801,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
    * {@link #isDestroyed()} this method will not return true if the cache is closing but has not yet
    * started closing this region.
    */
+  @Override
   public boolean isThisRegionBeingClosedOrDestroyed() {
     return this.isDestroyed;
   }
@@ -2900,6 +2905,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
    * @return true if cacheWrite was performed
    * @see DistributedRegion#cacheWriteBeforeDestroy(EntryEventImpl, Object)
    */
+  @Override
   public boolean cacheWriteBeforeDestroy(EntryEventImpl event, Object expectedOldValue)
       throws CacheWriterException, EntryNotFoundException, TimeoutException {
     boolean result = false;
@@ -3204,6 +3210,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
     return this.tombstoneCount.get();
   }
 
+  @Override
   public void scheduleTombstone(RegionEntry entry, VersionTag destroyedVersion) {
     scheduleTombstone(entry, destroyedVersion, false);
   }
@@ -3237,6 +3244,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
     scheduleTombstone(entry, version, true);
   }
 
+  @Override
   public void unscheduleTombstone(RegionEntry entry) {
     unscheduleTombstone(entry, true);
   }
@@ -3380,6 +3388,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
    *
    * @since GemFire 3.2
    */
+  @Override
   public Object getValueInVM(Object key) throws EntryNotFoundException {
     return basicGetValueInVM(key, true);
   }
@@ -3450,6 +3459,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
    *
    * @since GemFire 3.2
    */
+  @Override
   public Object getValueOnDisk(Object key) throws EntryNotFoundException {
     // Ok for this to ignore tx state
     RegionEntry re = this.entries.getEntry(key);
@@ -4960,6 +4970,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
   /**
    * invoke callbacks for an invalidation
    */
+  @Override
   public void invokeInvalidateCallbacks(final EnumListenerEvent eventType,
       final EntryEventImpl event, final boolean callDispatchListenerEvent) {
     // Notify bridge clients (if this is a CacheServer)
@@ -5877,6 +5888,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
     }
   }
 
+  @Override
   public void invokePutCallbacks(final EnumListenerEvent eventType, final EntryEventImpl event,
       final boolean callDispatchListenerEvent, boolean notifyGateways) {
 
@@ -5930,6 +5942,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
   /**
    * generate version tag if it does not exist and set it into the event.
    */
+  @Override
   public void generateAndSetVersionTag(InternalCacheEvent event, RegionEntry entry) {
     if (entry != null && event.getOperation().isEntry()) {
       EntryEventImpl entryEvent = (EntryEventImpl) event;
@@ -5947,10 +5960,16 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
   /**
    * record the event's sequenceId in Region's event state to prevent replay.
    */
+  @Override
   public void recordEvent(InternalCacheEvent event) {
     getEventTracker().recordEvent(event);
   }
 
+  @Override
+  public boolean isConcurrencyChecksEnabled() {
+    return this.concurrencyChecksEnabled;
+  }
+
   /**
    * has the Region's event state seen this event?
    * 
@@ -6717,6 +6736,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
     }
   }
 
+  @Override
   public void invokeDestroyCallbacks(final EnumListenerEvent eventType, final EntryEventImpl event,
       final boolean callDispatchListenerEvent, boolean notifyGateways) {
 
@@ -6885,7 +6905,8 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
     return expTime != 0 && expTime <= cacheTimeMillis();
   }
 
-  void dispatchListenerEvent(EnumListenerEvent op, InternalCacheEvent event) {
+  @Override
+  public void dispatchListenerEvent(EnumListenerEvent op, InternalCacheEvent event) {
     // Return if the inhibit all notifications flag is set
     boolean isEntryEvent = event instanceof EntryEventImpl;
     if (isEntryEvent) {
@@ -7065,6 +7086,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
    *
    * @return the actual lastModifiedTime used.
    */
+  @Override
   public long updateStatsForPut(RegionEntry entry, long lastModified, boolean lruRecentUse) {
     long lastAccessed = cacheTimeMillis();
     if (lruRecentUse) {
@@ -7775,8 +7797,9 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
     }
   }
 
-  public void addExpiryTaskIfAbsent(RegionEntry re) {
-    addExpiryTask(re, true);
+  @Override
+  public void addExpiryTaskIfAbsent(RegionEntry entry) {
+    addExpiryTask(entry, true);
   }
 
   void addExpiryTask(RegionEntry re) {
@@ -8143,6 +8166,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
   /**
    * get the ImageState for this region
    */
+  @Override
   public ImageState getImageState() {
     return this.imageState;
   }
@@ -8513,6 +8537,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
           return this.currentIterator != null && this.currentIterator.hasNext();
         }
 
+        @Override
         public Object next() {
           return next(false);
         }
@@ -8758,6 +8783,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
   /**
    * For internal use only.
    */
+  @Override
   public RegionMap getRegionMap() {
     // OK to ignore tx state
     return this.entries;
@@ -10222,9 +10248,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
     // nothing needs to be done here since LocalRegion does not have an advisor.
   }
 
-  /**
-   * @return Returns the isUsedForPartitionedRegionAdmin.
-   */
+  @Override
   public boolean isUsedForPartitionedRegionAdmin() {
     return this.isUsedForPartitionedRegionAdmin;
   }
@@ -10488,6 +10512,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
   /**
    * Returns the CQ/interest profile for this region
    */
+  @Override
   public FilterProfile getFilterProfile() {
     return this.filterProfile;
   }
@@ -10697,6 +10722,7 @@ public class LocalRegion extends AbstractRegion implements InternalRegion, Loade
   }
 
   // TODO: return value is never used
+  @Override
   public int updateSizeOnEvict(Object key, int oldSize) {
     // Only needed by BucketRegion
     return 0;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/NonLocalRegionEntry.java b/geode-core/src/main/java/org/apache/geode/internal/cache/NonLocalRegionEntry.java
index ba14606..32c06c7 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/NonLocalRegionEntry.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/NonLocalRegionEntry.java
@@ -37,7 +37,7 @@ import org.apache.geode.internal.cache.DistributedRegion;
 import org.apache.geode.internal.cache.EntryEventImpl;
 import org.apache.geode.internal.cache.EntrySnapshot;
 import org.apache.geode.internal.cache.InitialImageOperation.Entry;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.RegionClearedException;
 import org.apache.geode.internal.cache.RegionEntry;
 import org.apache.geode.internal.cache.RegionEntryContext;
@@ -60,10 +60,10 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
    * Create one of these in the local case so that we have a snapshot of the state and can allow the
    * bucket to move out from under us.
    */
-  public NonLocalRegionEntry(RegionEntry re, LocalRegion br, boolean allowTombstones) {
+  public NonLocalRegionEntry(RegionEntry re, InternalRegion br, boolean allowTombstones) {
     this.key = re.getKey();
-    if (allowTombstones && re.isTombstone()) { // client get() operations need to see tombstone
-                                               // values
+    if (allowTombstones && re.isTombstone()) {
+      // client get() operations need to see tombstone values
       this.value = Token.TOMBSTONE;
     } else {
       this.value = re.getValue(br); // OFFHEAP: copy into heap cd
@@ -82,22 +82,18 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
    * Create one of these in the local case so that we have a snapshot of the state and can allow the
    * bucket to move out from under us.
    */
-  public NonLocalRegionEntry(LocalRegion br, Object key, Object value) {
+  public NonLocalRegionEntry(InternalRegion br, Object key, Object value) {
     this.key = key;
     this.value = value;
     Assert.assertTrue(this.value != Token.NOT_AVAILABLE,
         "getEntry did not fault value in from disk");
-    // this.lastModified = re.getLastModified();
-    // this.isRemoved = re.isRemoved();
   }
 
-
-
   /**
    * Create one of these in the local case so that we have a snapshot of the state and can allow the
    * bucket to move out from under us.
    */
-  public NonLocalRegionEntry(Region.Entry re, LocalRegion br) {
+  public NonLocalRegionEntry(Region.Entry re, InternalRegion br) {
     this.key = re.getKey();
     this.value = re.getValue();
     if (this.value instanceof CachedDeserializable) {
@@ -124,27 +120,33 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
         + this.versionTag;
   }
 
-  public void makeTombstone(LocalRegion r, VersionTag isOperationRemote) {
+  @Override
+  public void makeTombstone(InternalRegion region, VersionTag version) {
     throw new UnsupportedOperationException();
   }
 
+  @Override
   public boolean dispatchListenerEvents(EntryEventImpl event) {
     throw new UnsupportedOperationException();
   }
 
+  @Override
   public VersionStamp getVersionStamp() {
     return this;
   }
 
+  @Override
   public boolean hasValidVersion() {
     return this.versionTag != null && this.versionTag.hasValidVersion();
   }
 
+  @Override
   public void setVersionTimeStamp(long time) {
     throw new UnsupportedOperationException();
   }
 
-  public void processVersionTag(EntryEvent ev) {
+  @Override
+  public void processVersionTag(EntryEvent event) {
     throw new UnsupportedOperationException();
   }
 
@@ -168,51 +170,63 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
     this.versionTag = (VersionTag) DataSerializer.readObject(in);
   }
 
+  @Override
   public long getLastModified() {
     return this.lastModified;
   }
 
+  @Override
   public long getLastAccessed() throws StatisticsDisabledException {
     return -1;
   }
 
+  @Override
   public long getHitCount() throws StatisticsDisabledException {
     return -1;
   }
 
+  @Override
   public long getMissCount() throws StatisticsDisabledException {
     return -1;
   }
 
+  @Override
   public boolean isRemoved() {
     return this.isRemoved;
   }
 
+  @Override
   public boolean isRemovedPhase2() {
     return this.isRemoved;
   }
 
+  @Override
   public boolean isTombstone() {
     return false;
   }
 
-  public boolean fillInValue(LocalRegion r, Entry entry, ByteArrayDataInput in, DM mgr,
-      final Version version) {
+  @Override
+  public boolean fillInValue(InternalRegion region, Entry entry, ByteArrayDataInput in,
+      DM distributionManager, final Version version) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
-  public boolean isOverflowedToDisk(LocalRegion r, DistributedRegion.DiskPosition dp) {
+  @Override
+  public boolean isOverflowedToDisk(InternalRegion region,
+      DistributedRegion.DiskPosition diskPosition) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
+  @Override
   public Object getKey() {
     return this.key;
   }
 
+  @Override
   public Object getValue(RegionEntryContext context) {
     return this.value;
   }
@@ -228,45 +242,53 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
   }
 
   // now for the fun part
+  @Override
   public void updateStatsForPut(long lastModifiedTime, long lastAccessedTime) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
+  @Override
   public void setRecentlyUsed() {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
+  @Override
   public void updateStatsForGet(boolean hit, long time) throws StatisticsDisabledException {
     // this method has been made a noop to fix bug 37436
   }
 
-  public void txDidDestroy(long currTime) {
+  @Override
+  public void txDidDestroy(long currentTime) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
+  @Override
   public void resetCounts() throws StatisticsDisabledException {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
-  public void removePhase1(LocalRegion r, boolean isClear) {
+  @Override
+  public void removePhase1(InternalRegion region, boolean clear) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
+  @Override
   public void removePhase2() {
     throw new UnsupportedOperationException(
         "Not appropriate for PartitionedRegion.NonLocalRegionEntry");
   }
 
+  @Override
   public void setValue(RegionEntryContext context, Object value) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
@@ -274,7 +296,7 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
   }
 
   @Override
-  public Object _getValue() {
+  public Object getValue() {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
@@ -288,7 +310,7 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
   }
 
   @Override
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(RegionEntryContext context, boolean decompress) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
@@ -301,31 +323,36 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
             .toLocalizedString());
   }
 
+  @Override
   public Object getValueInVM(RegionEntryContext context) {
     return this.value;
   }
 
-  public Object getValueOnDisk(LocalRegion r) throws EntryNotFoundException {
+  @Override
+  public Object getValueOnDisk(InternalRegion region) throws EntryNotFoundException {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
-  public boolean initialImagePut(LocalRegion region, long lastModified1, Object newValue,
-      boolean wasRecovered, boolean versionTagAccepted) {
+  @Override
+  public boolean initialImagePut(InternalRegion region, long lastModified, Object newValue,
+      boolean wasRecovered, boolean acceptedVersionTag) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
-  public boolean initialImageInit(LocalRegion region, long lastModified1, Object newValue,
-      boolean create, boolean wasRecovered, boolean versionTagAccepted) {
+  @Override
+  public boolean initialImageInit(InternalRegion region, long lastModified, Object newValue,
+      boolean create, boolean wasRecovered, boolean acceptedVersionTag) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
-  public boolean destroy(LocalRegion region, EntryEventImpl event, boolean inTokenMode,
+  @Override
+  public boolean destroy(InternalRegion region, EntryEventImpl event, boolean inTokenMode,
       boolean cacheWrite, Object expectedOldValue, boolean forceDestroy,
       boolean removeRecoveredEntry)
       throws CacheWriterException, EntryNotFoundException, TimeoutException {
@@ -334,48 +361,47 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
             .toLocalizedString());
   }
 
+  @Override
   public boolean getValueWasResultOfSearch() {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
-  public void setValueResultOfSearch(boolean v) {
+  @Override
+  public void setValueResultOfSearch(boolean value) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
-  /*
-   * (non-Javadoc)
-   * 
-   * @see
-   * org.apache.geode.internal.cache.RegionEntry#getValueOnDiskOrBuffer(org.apache.geode.internal.
-   * cache.LocalRegion)
-   */
-  public Object getValueOnDiskOrBuffer(LocalRegion r) throws EntryNotFoundException {
+  @Override
+  public Object getValueOnDiskOrBuffer(InternalRegion region) throws EntryNotFoundException {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
-  public Object getSerializedValueOnDisk(LocalRegion localRegion) {
+  @Override
+  public Object getSerializedValueOnDisk(InternalRegion region) {
     throw new UnsupportedOperationException(
         LocalizedStrings.PartitionedRegion_NOT_APPROPRIATE_FOR_PARTITIONEDREGIONNONLOCALREGIONENTRY
             .toLocalizedString());
   }
 
 
+  @Override
   public boolean hasStats() {
     return false;
   }
 
-  public Object getValueInVMOrDiskWithoutFaultIn(LocalRegion owner) {
+  @Override
+  public Object getValueInVMOrDiskWithoutFaultIn(InternalRegion region) {
     return this.value;
   }
 
   @Override
-  public Object getValueOffHeapOrDiskWithoutFaultIn(LocalRegion owner) {
+  public Object getValueOffHeapOrDiskWithoutFaultIn(InternalRegion region) {
     return this.value;
   }
 
@@ -383,41 +409,18 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
     this.key = key2;
   }
 
-  // VersionStamp methods ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see
-   * org.apache.geode.internal.cache.RegionEntry#generateVersionTag(org.apache.geode.distributed.
-   * DistributedMember, boolean)
-   */
-  public VersionTag generateVersionTag(VersionSource member, boolean withDelta, LocalRegion region,
-      EntryEventImpl event) {
+  @Override
+  public VersionTag generateVersionTag(VersionSource member, boolean withDelta,
+      InternalRegion region, EntryEventImpl event) {
     throw new UnsupportedOperationException(); // no text needed - not a customer visible method
   }
 
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see
-   * org.apache.geode.internal.cache.RegionEntry#concurrencyCheck(org.apache.geode.internal.cache.
-   * LocalRegion, org.apache.geode.internal.cache.versions.VersionTag,
-   * org.apache.geode.distributed.internal.membership.InternalDistributedMember,
-   * org.apache.geode.distributed.internal.membership.InternalDistributedMember)
-   */
-  public void processVersionTag(LocalRegion r, VersionTag tag, InternalDistributedMember thisVM,
+  public void processVersionTag(InternalRegion r, VersionTag tag, InternalDistributedMember thisVM,
       InternalDistributedMember sender) {
     throw new UnsupportedOperationException();
   }
 
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see org.apache.geode.internal.cache.versions.VersionStamp#getEntryVersion()
-   */
+  @Override
   public int getEntryVersion() {
     if (this.versionTag != null) {
       return this.versionTag.getEntryVersion();
@@ -425,6 +428,7 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
     return 0;
   }
 
+  @Override
   public long getRegionVersion() {
     if (this.versionTag != null) {
       return this.versionTag.getRegionVersion();
@@ -432,11 +436,7 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
     return 0;
   }
 
-  /*
-   * (non-Javadoc)
-   * 
-   * @see org.apache.geode.internal.cache.versions.VersionStamp#getMemberID()
-   */
+  @Override
   public VersionSource getMemberID() {
     if (this.versionTag != null) {
       return this.versionTag.getMemberID();
@@ -444,6 +444,7 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
     return null;
   }
 
+  @Override
   public int getDistributedSystemId() {
     if (this.versionTag != null) {
       return this.versionTag.getDistributedSystemId();
@@ -451,81 +452,45 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
     return -1;
   }
 
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see org.apache.geode.internal.cache.versions.VersionStamp#setEntryVersion(int)
-   */
+  @Override
   public void setVersions(VersionTag tag) {
     throw new UnsupportedOperationException();
   }
 
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see
-   * org.apache.geode.internal.cache.versions.VersionStamp#setMemberID(org.apache.geode.distributed.
-   * DistributedMember)
-   */
+  @Override
   public void setMemberID(VersionSource memberID) {
     throw new UnsupportedOperationException();
   }
 
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see
-   * org.apache.geode.internal.cache.versions.VersionStamp#setPreviousMemberID(org.apache.geode.
-   * distributed.DistributedMember)
-   */
   public void setPreviousMemberID(DistributedMember previousMemberID) {
     throw new UnsupportedOperationException();
   }
 
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see org.apache.geode.internal.cache.versions.VersionStamp#asVersionTag()
-   */
+  @Override
   public VersionTag asVersionTag() {
     return this.versionTag;
   }
 
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see org.apache.geode.internal.cache.versions.VersionStamp#processVersionTag(org.apache.geode.
-   * internal.cache.LocalRegion, org.apache.geode.internal.cache.versions.VersionTag, boolean,
-   * org.apache.geode.distributed.internal.membership.InternalDistributedMember,
-   * org.apache.geode.distributed.internal.membership.InternalDistributedMember)
-   */
-  public void processVersionTag(LocalRegion r, VersionTag tag, boolean isTombstoneFromGII,
-      boolean hasDelta, VersionSource thisVM, InternalDistributedMember sender,
-      boolean checkForConflicts) {
+  @Override
+  public void processVersionTag(InternalRegion region, VersionTag tag, boolean isTombstoneFromGII,
+      boolean hasDelta, VersionSource versionSource, InternalDistributedMember sender,
+      boolean checkConflicts) {
     throw new UnsupportedOperationException();
   }
 
-  /*
-   * (non-Javadoc)
-   * 
-   * @see org.apache.geode.internal.cache.versions.VersionStamp#getVersionTimeStamp()
-   */
   @Override
   public long getVersionTimeStamp() {
     return this.versionTag != null ? this.versionTag.getVersionTimeStamp() : 0;
   }
 
   /** get rvv internal high byte. Used by region entries for transferring to storage */
+  @Override
   public short getRegionVersionHighBytes() {
     return this.versionTag != null ? this.versionTag.getRegionVersionHighBytes() : 0;
   }
 
   /** get rvv internal low bytes. Used by region entries for transferring to storage */
+  @Override
   public int getRegionVersionLowBytes() {
     return this.versionTag != null ? this.versionTag.getRegionVersionLowBytes() : 0;
   }
@@ -631,24 +596,33 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
   }
 
   @Override
-  public void setInUseByTransaction(boolean v) {}
+  public void setInUseByTransaction(boolean inUseByTransaction) {
+    // nothing
+  }
 
   @Override
-  public void incRefCount() {}
+  public void incRefCount() {
+    // nothing
+  }
 
   @Override
-  public void decRefCount(NewLRUClockHand lruList, LocalRegion lr) {}
+  public void decRefCount(NewLRUClockHand lruList, InternalRegion region) {
+    // nothing
+  }
 
   @Override
-  public void resetRefCount(NewLRUClockHand lruList) {}
+  public void resetRefCount(NewLRUClockHand lruList) {
+    // nothing
+  }
 
   @Override
-  public Object prepareValueForCache(RegionEntryContext r, Object val, boolean isEntryUpdate) {
+  public Object prepareValueForCache(RegionEntryContext context, Object value,
+      boolean isEntryUpdate) {
     throw new IllegalStateException("Should never be called");
   }
 
   @Override
-  public Object prepareValueForCache(RegionEntryContext r, Object val, EntryEventImpl event,
+  public Object prepareValueForCache(RegionEntryContext context, Object value, EntryEventImpl event,
       boolean isEntryUpdate) {
     throw new IllegalStateException("Should never be called");
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/Oplog.java b/geode-core/src/main/java/org/apache/geode/internal/cache/Oplog.java
index bf047e0..53ca850 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/Oplog.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/Oplog.java
@@ -1270,7 +1270,8 @@ public class Oplog implements CompactableOplog, Flushable {
    *        present. @param faultingIn @param bitOnly boolean indicating whether to extract just the
    *        UserBit or UserBit with value @return BytesAndBits object wrapping the value & user bit
    */
-  public BytesAndBits getBytesAndBits(DiskRegionView dr, DiskId id, boolean faultingIn,
+  @Override
+  public BytesAndBits getBytesAndBits(DiskRegionView dr, DiskId id, boolean faultIn,
       boolean bitOnly) {
     Oplog retryOplog = null;
     long offset = 0;
@@ -1286,7 +1287,7 @@ public class Oplog implements CompactableOplog, Flushable {
       }
     }
     if (retryOplog != null) {
-      return retryOplog.getBytesAndBits(dr, id, faultingIn, bitOnly);
+      return retryOplog.getBytesAndBits(dr, id, faultIn, bitOnly);
     }
     BytesAndBits bb = null;
     long start = this.stats.startRead();
@@ -1335,6 +1336,7 @@ public class Oplog implements CompactableOplog, Flushable {
    * 
    * @param id A DiskId object for which the value on disk will be fetched
    */
+  @Override
   public BytesAndBits getNoBuffer(DiskRegion dr, DiskId id) {
     if (logger.isDebugEnabled()) {
       logger.debug("Oplog::getNoBuffer:Before invoking Oplog.basicGet for DiskID ={}", id);
@@ -3505,7 +3507,7 @@ public class Oplog implements CompactableOplog, Flushable {
    * @param entry The DiskEntry object for this key/value pair.
    * @param value byte array representing the value
    */
-  public void create(LocalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
+  public void create(InternalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
 
     if (this != getOplogSet().getChild()) {
       getOplogSet().getChild().create(region, entry, value, async);
@@ -3820,6 +3822,7 @@ public class Oplog implements CompactableOplog, Flushable {
       // RAF
       // as needed.
       getParent().executeDelayedExpensiveWrite(new Runnable() {
+        @Override
         public void run() {
           // need to truncate crf and drf if their actual size is less than
           // their pregrow size
@@ -3871,6 +3874,7 @@ public class Oplog implements CompactableOplog, Flushable {
    */
   protected void createKrfAsync() {
     getParent().executeDiskStoreTask(new Runnable() {
+      @Override
       public void run() {
         createKrf(false);
       }
@@ -4118,7 +4122,6 @@ public class Oplog implements CompactableOplog, Flushable {
 
       allClosed = true;
     } catch (IOException e) {
-      // TODO Auto-generated catch block
       if (getParent().getDiskAccessException() == null) {
         throw new DiskAccessException("Fail to close krf file " + this.krf.f, e, getParent());
       } else {
@@ -4210,14 +4213,13 @@ public class Oplog implements CompactableOplog, Flushable {
               CacheObserverHolder.getInstance().afterKrfCreated();
             }
           } catch (FileNotFoundException ex) {
-            // TODO handle exception; we couldn't open the krf file
+            // we couldn't open the krf file
             throw new IllegalStateException("could not create krf " + this.krf.f, ex);
           } catch (IOException ex) {
-            // TODO handle io exceptions; we failed to write to the file
+            // we failed to write to the file
             throw new IllegalStateException("failed writing krf " + this.krf.f, ex);
           } finally {
-            // if IOException happened in writeOneKeyEntryForKRF(), delete krf
-            // here
+            // if IOException happened in writeOneKeyEntryForKRF(), delete krf here
             if (!krfCreateSuccess) {
               closeAndDeleteKrf();
             }
@@ -4252,6 +4254,7 @@ public class Oplog implements CompactableOplog, Flushable {
     }
     // idx is now the length of sortedLiveEntries
     Arrays.sort(sortedLiveEntries, 0, idx, new Comparator<KRFEntry>() {
+      @Override
       public int compare(KRFEntry o1, KRFEntry o2) {
         long val1 = o1.getOffsetInOplogForSorting();
         long val2 = o2.getOffsetInOplogForSorting();
@@ -4283,7 +4286,7 @@ public class Oplog implements CompactableOplog, Flushable {
     ReferenceCountHelper.skipRefCountTracking();
     @Retained
     @Released
-    Object value = entry._getValueRetain(dr, true);
+    Object value = entry.getValueRetain(dr, true);
     ReferenceCountHelper.unskipRefCountTracking();
     boolean foundData = false;
     if (value == null) {
@@ -4427,7 +4430,7 @@ public class Oplog implements CompactableOplog, Flushable {
    * 
    * @param value byte array representing the value
    */
-  public void modify(LocalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
+  public void modify(InternalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
     if (getOplogSet().getChild() != this) {
       getOplogSet().getChild().modify(region, entry, value, async);
     } else {
@@ -4506,7 +4509,7 @@ public class Oplog implements CompactableOplog, Flushable {
     }
   }
 
-  public void saveConflictVersionTag(LocalRegion region, VersionTag tag, boolean async) {
+  public void saveConflictVersionTag(InternalRegion region, VersionTag tag, boolean async) {
     if (getOplogSet().getChild() != this) {
       getOplogSet().getChild().saveConflictVersionTag(region, tag, async);
     } else {
@@ -4910,7 +4913,7 @@ public class Oplog implements CompactableOplog, Flushable {
    * 
    * @param entry DiskEntry object on which remove operation is called
    */
-  public void remove(LocalRegion region, DiskEntry entry, boolean async, boolean isClear) {
+  public void remove(InternalRegion region, DiskEntry entry, boolean async, boolean isClear) {
     DiskRegion dr = region.getDiskRegion();
     if (getOplogSet().getChild() != this) {
       getOplogSet().getChild().remove(region, entry, async, isClear);
@@ -5168,13 +5171,13 @@ public class Oplog implements CompactableOplog, Flushable {
   }
 
   @Override
-  public void flush(ByteBuffer b1, ByteBuffer b2) throws IOException {
-    if (b1 == this.drf.writeBuf) {
-      flush(this.drf, b1, b2);
+  public void flush(ByteBuffer bb, ByteBuffer chunkbb) throws IOException {
+    if (bb == this.drf.writeBuf) {
+      flush(this.drf, bb, chunkbb);
       flush(this.crf, false);
     } else {
       flush(this.drf, false);
-      flush(this.crf, b1, b2);
+      flush(this.crf, bb, chunkbb);
     }
   }
 
@@ -5729,6 +5732,7 @@ public class Oplog implements CompactableOplog, Flushable {
         return;
       }
       getParent().executeDelayedExpensiveWrite(new Runnable() {
+        @Override
         public void run() {
           if (!krf.delete()) {
             if (krf.exists()) {
@@ -5795,6 +5799,7 @@ public class Oplog implements CompactableOplog, Flushable {
       // bounded
       // queue
       getParent().executeDelayedExpensiveWrite(new Runnable() {
+        @Override
         public void run() {
           if (!olf.f.delete() && olf.f.exists()) {
             logger.warn(LocalizedMessage.create(LocalizedStrings.Oplog_DELETE_FAIL_0_1_2,
@@ -5972,6 +5977,7 @@ public class Oplog implements CompactableOplog, Flushable {
         } else {
           // schedule another thread to do it
           getParent().executeDiskStoreTask(new Runnable() {
+            @Override
             public void run() {
               handleEmptyAndOldest(false);
             }
@@ -5984,6 +5990,7 @@ public class Oplog implements CompactableOplog, Flushable {
         } else {
           // schedule another thread to do it
           getParent().executeDiskStoreTask(new Runnable() {
+            @Override
             public void run() {
               handleEmpty(false);
             }
@@ -6036,6 +6043,7 @@ public class Oplog implements CompactableOplog, Flushable {
     }
   }
 
+  @Override
   public void prepareForCompact() {
     this.compacting = true;
   }
@@ -6054,6 +6062,7 @@ public class Oplog implements CompactableOplog, Flushable {
    * Copy any live entries last stored in this oplog to the current oplog. No need to copy deletes
    * in the drf. Backup only needs them until all the older crfs are empty.
    */
+  @Override
   public int compact(OplogCompactor compactor) {
     if (!needsCompaction()) {
       return 0; // @todo check new logic that deals with not compacting oplogs
@@ -6884,18 +6893,22 @@ public class Oplog implements CompactableOplog, Flushable {
     private DiskEntry next = this;
     private DiskEntry prev = this;
 
+    @Override
     public synchronized DiskEntry getPrev() {
       return this.prev;
     }
 
+    @Override
     public synchronized void setPrev(DiskEntry v) {
       this.prev = v;
     }
 
+    @Override
     public synchronized DiskEntry getNext() {
       return this.next;
     }
 
+    @Override
     public synchronized void setNext(DiskEntry v) {
       this.next = v;
     }
@@ -7000,7 +7013,7 @@ public class Oplog implements CompactableOplog, Flushable {
     }
 
     @Override
-    public Object _getValue() {
+    public Object getValue() {
       throw new IllegalStateException();
     }
 
@@ -7015,12 +7028,13 @@ public class Oplog implements CompactableOplog, Flushable {
     }
 
     @Override
-    public Object prepareValueForCache(RegionEntryContext r, Object val, boolean isEntryUpdate) {
+    public Object prepareValueForCache(RegionEntryContext context, Object value,
+        boolean isEntryUpdate) {
       throw new IllegalStateException("Should never be called");
     }
 
     @Override
-    public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+    public Object getValueRetain(RegionEntryContext context, boolean decompress) {
       throw new IllegalStateException();
     }
 
@@ -7033,10 +7047,12 @@ public class Oplog implements CompactableOplog, Flushable {
       throw new IllegalStateException();
     }
 
+    @Override
     public DiskId getDiskId() {
       throw new IllegalStateException();
     }
 
+    @Override
     public long getLastModified() {
       throw new IllegalStateException();
     }
@@ -7045,14 +7061,17 @@ public class Oplog implements CompactableOplog, Flushable {
       throw new IllegalStateException();
     }
 
+    @Override
     public boolean isValueNull() {
       throw new IllegalStateException();
     }
 
+    @Override
     public boolean isRemovedFromDisk() {
       throw new IllegalStateException();
     }
 
+    @Override
     public int updateAsyncEntrySize(EnableLRU capacityController) {
       throw new IllegalStateException();
     }
@@ -7094,115 +7113,104 @@ public class Oplog implements CompactableOplog, Flushable {
 
     @Override
     public boolean hasStats() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public long getLastAccessed() throws InternalStatisticsDisabledException {
-      // TODO Auto-generated method stub
       return 0;
     }
 
     @Override
     public long getHitCount() throws InternalStatisticsDisabledException {
-      // TODO Auto-generated method stub
       return 0;
     }
 
     @Override
     public long getMissCount() throws InternalStatisticsDisabledException {
-      // TODO Auto-generated method stub
       return 0;
     }
 
     @Override
     public void updateStatsForPut(long lastModifiedTime, long lastAccessedTime) {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public VersionTag generateVersionTag(VersionSource member, boolean withDelta,
-        LocalRegion region, EntryEventImpl event) {
-      // TODO Auto-generated method stub
+        InternalRegion region, EntryEventImpl event) {
       return null;
     }
 
     @Override
     public boolean dispatchListenerEvents(EntryEventImpl event) throws InterruptedException {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public void setRecentlyUsed() {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public void updateStatsForGet(boolean hit, long time) {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
-    public void txDidDestroy(long currTime) {
-      // TODO Auto-generated method stub
+    public void txDidDestroy(long currentTime) {
+      // nothing
     }
 
     @Override
     public void resetCounts() throws InternalStatisticsDisabledException {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
-    public void makeTombstone(LocalRegion r, VersionTag version) throws RegionClearedException {
-      // TODO Auto-generated method stub
+    public void makeTombstone(InternalRegion region, VersionTag version)
+        throws RegionClearedException {
+      // nothing
     }
 
     @Override
-    public void removePhase1(LocalRegion r, boolean clear) throws RegionClearedException {
-      // TODO Auto-generated method stub
+    public void removePhase1(InternalRegion region, boolean clear) throws RegionClearedException {
+      // nothing
     }
 
     @Override
     public void removePhase2() {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public boolean isRemoved() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isRemovedPhase2() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isTombstone() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
-    public boolean fillInValue(LocalRegion r, InitialImageOperation.Entry entry,
-        ByteArrayDataInput in, DM mgr, final Version version) {
-      // TODO Auto-generated method stub
+    public boolean fillInValue(InternalRegion region, InitialImageOperation.Entry entry,
+        ByteArrayDataInput in, DM distributionManager, final Version version) {
       return false;
     }
 
     @Override
-    public boolean isOverflowedToDisk(LocalRegion r, DiskPosition dp) {
-      // TODO Auto-generated method stub
+    public boolean isOverflowedToDisk(InternalRegion region, DiskPosition diskPosition) {
       return false;
     }
 
     @Override
     public Object getValue(RegionEntryContext context) {
-      // TODO Auto-generated method stub
       return null;
     }
 
@@ -7213,153 +7221,134 @@ public class Oplog implements CompactableOplog, Flushable {
 
     @Override
     public void setValue(RegionEntryContext context, Object value) throws RegionClearedException {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public void setValueWithTombstoneCheck(Object value, EntryEvent event)
         throws RegionClearedException {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public Object getTransformedValue() {
-      // TODO Auto-generated method stub
       return null;
     }
 
     @Override
     public Object getValueInVM(RegionEntryContext context) {
-      // TODO Auto-generated method stub
       return null;
     }
 
     @Override
-    public Object getValueOnDisk(LocalRegion r) throws EntryNotFoundException {
-      // TODO Auto-generated method stub
+    public Object getValueOnDisk(InternalRegion region) throws EntryNotFoundException {
       return null;
     }
 
     @Override
-    public Object getValueOnDiskOrBuffer(LocalRegion r) throws EntryNotFoundException {
-      // TODO Auto-generated method stub
+    public Object getValueOnDiskOrBuffer(InternalRegion region) throws EntryNotFoundException {
       return null;
     }
 
     @Override
-    public boolean initialImagePut(LocalRegion region, long lastModified, Object newValue,
+    public boolean initialImagePut(InternalRegion region, long lastModified, Object newValue,
         boolean wasRecovered, boolean acceptedVersionTag) throws RegionClearedException {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
-    public boolean initialImageInit(LocalRegion region, long lastModified, Object newValue,
+    public boolean initialImageInit(InternalRegion region, long lastModified, Object newValue,
         boolean create, boolean wasRecovered, boolean acceptedVersionTag)
         throws RegionClearedException {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
-    public boolean destroy(LocalRegion region, EntryEventImpl event, boolean inTokenMode,
+    public boolean destroy(InternalRegion region, EntryEventImpl event, boolean inTokenMode,
         boolean cacheWrite, Object expectedOldValue, boolean forceDestroy,
         boolean removeRecoveredEntry) throws CacheWriterException, EntryNotFoundException,
         TimeoutException, RegionClearedException {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean getValueWasResultOfSearch() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
-    public void setValueResultOfSearch(boolean v) {
-      // TODO Auto-generated method stub
+    public void setValueResultOfSearch(boolean value) {
+      // nothing
     }
 
     @Override
-    public Object getSerializedValueOnDisk(LocalRegion localRegion) {
-      // TODO Auto-generated method stub
+    public Object getSerializedValueOnDisk(InternalRegion region) {
       return null;
     }
 
     @Override
-    public Object getValueInVMOrDiskWithoutFaultIn(LocalRegion owner) {
-      // TODO Auto-generated method stub
+    public Object getValueInVMOrDiskWithoutFaultIn(InternalRegion region) {
       return null;
     }
 
     @Override
-    public Object getValueOffHeapOrDiskWithoutFaultIn(LocalRegion owner) {
-      // TODO Auto-generated method stub
+    public Object getValueOffHeapOrDiskWithoutFaultIn(InternalRegion region) {
       return null;
     }
 
     @Override
     public boolean isUpdateInProgress() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public void setUpdateInProgress(boolean underUpdate) {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public boolean isInvalid() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isDestroyed() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isDestroyedOrRemoved() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isDestroyedOrRemovedButNotTombstone() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isInvalidOrRemoved() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public void setValueToNull() {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public void returnToPool() {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public boolean isCacheListenerInvocationInProgress() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public void setCacheListenerInvocationInProgress(boolean isListenerInvoked) {
-      // TODO Auto-generated method stub
-
+      // nothing
     }
 
     @Override
@@ -7372,20 +7361,28 @@ public class Oplog implements CompactableOplog, Flushable {
     }
 
     @Override
-    public void setInUseByTransaction(boolean v) {}
+    public void setInUseByTransaction(boolean inUseByTransaction) {
+      // nothing
+    }
 
     @Override
-    public void incRefCount() {}
+    public void incRefCount() {
+      // nothing
+    }
 
     @Override
-    public void decRefCount(NewLRUClockHand lruList, LocalRegion lr) {}
+    public void decRefCount(NewLRUClockHand lruList, InternalRegion region) {
+      // nothing
+    }
 
     @Override
-    public void resetRefCount(NewLRUClockHand lruList) {}
+    public void resetRefCount(NewLRUClockHand lruList) {
+      // nothing
+    }
 
     @Override
-    public Object prepareValueForCache(RegionEntryContext r, Object val, EntryEventImpl event,
-        boolean isEntryUpdate) {
+    public Object prepareValueForCache(RegionEntryContext context, Object value,
+        EntryEventImpl event, boolean isEntryUpdate) {
       throw new IllegalStateException("Should never be called");
     }
 
@@ -7439,20 +7436,26 @@ public class Oplog implements CompactableOplog, Flushable {
       this.dr = dr;
     }
 
+    @Override
     public abstract void addLive(DiskEntry de);
 
+    @Override
     public abstract DiskEntry getNextLiveEntry();
 
+    @Override
     public abstract long clear(RegionVersionVector rvv);
 
+    @Override
     public DiskRegionView getDiskRegion() {
       return this.dr;
     }
 
+    @Override
     public void setDiskRegion(DiskRegionView dr) {
       this.dr = dr;
     }
 
+    @Override
     synchronized public boolean testAndSetUnrecovered() {
       boolean result = !this.unrecovered;
       if (result) {
@@ -7462,10 +7465,12 @@ public class Oplog implements CompactableOplog, Flushable {
       return result;
     }
 
+    @Override
     synchronized public boolean getUnrecovered() {
       return this.unrecovered;
     }
 
+    @Override
     synchronized public boolean testAndSetRecovered(DiskRegionView dr) {
       boolean result = this.unrecovered;
       if (result) {
@@ -7511,11 +7516,13 @@ public class Oplog implements CompactableOplog, Flushable {
       return this.liveCount.getAndSet(0);
     }
 
+    @Override
     public int addLiveEntriesToList(KRFEntry[] liveEntries, int idx) {
       // nothing needed since no linked list
       return idx;
     }
 
+    @Override
     public void afterKrfCreated() {
       // do nothing
     }
@@ -7558,10 +7565,10 @@ public class Oplog implements CompactableOplog, Flushable {
     }
 
     @Override
-    public void update(DiskEntry de) {
-      if (pendingKrfTags != null && de.getVersionStamp() != null) {
+    public void update(DiskEntry entry) {
+      if (pendingKrfTags != null && entry.getVersionStamp() != null) {
         // Remember the version tag of the entry as it was written to the crf.
-        pendingKrfTags.put(de, new CompactVersionHolder(de.getVersionStamp()));
+        pendingKrfTags.put(entry, new CompactVersionHolder(entry.getVersionStamp()));
       }
     }
 
@@ -7619,6 +7626,7 @@ public class Oplog implements CompactableOplog, Flushable {
       return result;
     }
 
+    @Override
     public int addLiveEntriesToList(KRFEntry[] liveEntries, int idx) {
       synchronized (liveEntries) {
         return this.liveEntries.addLiveEntriesToList(liveEntries, idx, getDiskRegion(),
@@ -7626,6 +7634,7 @@ public class Oplog implements CompactableOplog, Flushable {
       }
     }
 
+    @Override
     public void afterKrfCreated() {
       synchronized (liveEntries) {
         this.pendingKrfTags = null;
@@ -7831,13 +7840,14 @@ public class Oplog implements CompactableOplog, Flushable {
     }
 
     @Override
-    public boolean equals(Object other) {
-      if (!(other instanceof RawByteKey)) {
+    public boolean equals(Object obj) {
+      if (!(obj instanceof RawByteKey)) {
         return false;
       }
-      return Arrays.equals(this.bytes, ((RawByteKey) other).bytes);
+      return Arrays.equals(this.bytes, ((RawByteKey) obj).bytes);
     }
 
+    @Override
     public void sendTo(DataOutput out) throws IOException {
       out.write(this.bytes);
     }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/OplogSet.java b/geode-core/src/main/java/org/apache/geode/internal/cache/OplogSet.java
index 5af1b93..7f59316 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/OplogSet.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/OplogSet.java
@@ -20,11 +20,11 @@ import org.apache.geode.internal.cache.entries.DiskEntry.Helper.ValueWrapper;
 public interface OplogSet {
 
 
-  public void create(LocalRegion region, DiskEntry entry, ValueWrapper value, boolean async);
+  public void create(InternalRegion region, DiskEntry entry, ValueWrapper value, boolean async);
 
-  public void modify(LocalRegion region, DiskEntry entry, ValueWrapper value, boolean async);
+  public void modify(InternalRegion region, DiskEntry entry, ValueWrapper value, boolean async);
 
   public CompactableOplog getChild(long oplogId);
 
-  public void remove(LocalRegion region, DiskEntry entry, boolean async, boolean isClear);
+  public void remove(InternalRegion region, DiskEntry entry, boolean async, boolean isClear);
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/OverflowOplogSet.java b/geode-core/src/main/java/org/apache/geode/internal/cache/OverflowOplogSet.java
index e91ed5a..0d0c23d 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/OverflowOplogSet.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/OverflowOplogSet.java
@@ -38,11 +38,9 @@ public class OverflowOplogSet implements OplogSet {
   private static final Logger logger = LogService.getLogger();
 
   private final AtomicInteger overflowOplogId = new AtomicInteger(0);
-  private OverflowOplog lastOverflowWrite = null;
-  private final ConcurrentMap<Integer, OverflowOplog> overflowMap =
-      new ConcurrentHashMap<Integer, OverflowOplog>();
-  private final Map<Integer, OverflowOplog> compactableOverflowMap =
-      new LinkedHashMap<Integer, OverflowOplog>();
+  private OverflowOplog lastOverflowWrite;
+  private final ConcurrentMap<Integer, OverflowOplog> overflowMap = new ConcurrentHashMap<>();
+  private final Map<Integer, OverflowOplog> compactibleOverflowMap = new LinkedHashMap<>();
 
   private int lastOverflowDir = 0;
 
@@ -52,14 +50,13 @@ public class OverflowOplogSet implements OplogSet {
     this.parent = parent;
   }
 
-
   OverflowOplog getActiveOverflowOplog() {
     return this.lastOverflowWrite;
   }
 
   @Override
-  public void modify(LocalRegion lr, DiskEntry entry, ValueWrapper value, boolean async) {
-    DiskRegion dr = lr.getDiskRegion();
+  public void modify(InternalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
+    DiskRegion dr = region.getDiskRegion();
     synchronized (this.overflowMap) {
       if (this.lastOverflowWrite != null) {
         if (this.lastOverflowWrite.modify(dr, entry, value, async)) {
@@ -83,7 +80,6 @@ public class OverflowOplogSet implements OplogSet {
     return parent.directories;
   }
 
-
   /**
    * @param minSize the minimum size this oplog can be
    */
@@ -164,8 +160,8 @@ public class OverflowOplogSet implements OplogSet {
 
   void removeOverflow(OverflowOplog oo) {
     if (!basicRemoveOverflow(oo)) {
-      synchronized (this.compactableOverflowMap) {
-        this.compactableOverflowMap.remove(oo.getOplogId());
+      synchronized (this.compactibleOverflowMap) {
+        this.compactibleOverflowMap.remove(oo.getOplogId());
       }
     }
   }
@@ -177,14 +173,12 @@ public class OverflowOplogSet implements OplogSet {
     return this.overflowMap.remove(oo.getOplogId(), oo);
   }
 
-
-
   public void closeOverflow() {
     for (OverflowOplog oo : this.overflowMap.values()) {
       oo.destroy();
     }
-    synchronized (this.compactableOverflowMap) {
-      for (OverflowOplog oo : this.compactableOverflowMap.values()) {
+    synchronized (this.compactibleOverflowMap) {
+      for (OverflowOplog oo : this.compactibleOverflowMap.values()) {
         oo.destroy();
       }
     }
@@ -206,8 +200,6 @@ public class OverflowOplogSet implements OplogSet {
     }
   }
 
-
-
   void copyForwardForOverflowCompact(DiskEntry de, byte[] valueBytes, int length, byte userBits) {
     synchronized (this.overflowMap) {
       if (this.lastOverflowWrite != null) {
@@ -233,37 +225,34 @@ public class OverflowOplogSet implements OplogSet {
   public OverflowOplog getChild(int oplogId) {
     OverflowOplog result = this.overflowMap.get(oplogId);
     if (result == null) {
-      synchronized (this.compactableOverflowMap) {
-        result = this.compactableOverflowMap.get(oplogId);
+      synchronized (this.compactibleOverflowMap) {
+        result = this.compactibleOverflowMap.get(oplogId);
       }
     }
     return result;
   }
 
-
   @Override
-  public void create(LocalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
+  public void create(InternalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
     modify(region, entry, value, async);
   }
 
-
   @Override
-  public void remove(LocalRegion region, DiskEntry entry, boolean async, boolean isClear) {
+  public void remove(InternalRegion region, DiskEntry entry, boolean async, boolean isClear) {
     removeOverflow(region.getDiskRegion(), entry);
   }
 
   void addOverflowToBeCompacted(OverflowOplog oplog) {
-    synchronized (this.compactableOverflowMap) {
-      this.compactableOverflowMap.put(oplog.getOplogId(), oplog);
+    synchronized (this.compactibleOverflowMap) {
+      this.compactibleOverflowMap.put(oplog.getOplogId(), oplog);
     }
     basicRemoveOverflow(oplog);
     parent.scheduleCompaction();
   }
 
-
   public void getCompactableOplogs(List<CompactableOplog> l, int max) {
-    synchronized (this.compactableOverflowMap) {
-      Iterator<OverflowOplog> itr = this.compactableOverflowMap.values().iterator();
+    synchronized (this.compactibleOverflowMap) {
+      Iterator<OverflowOplog> itr = this.compactibleOverflowMap.values().iterator();
       while (itr.hasNext() && l.size() < max) {
         OverflowOplog oplog = itr.next();
         if (oplog.needsCompaction()) {
@@ -283,8 +272,8 @@ public class OverflowOplogSet implements OplogSet {
         }
       }
     }
-    synchronized (this.compactableOverflowMap) {
-      for (OverflowOplog oo : this.compactableOverflowMap.values()) {
+    synchronized (this.compactibleOverflowMap) {
+      for (OverflowOplog oo : this.compactibleOverflowMap.values()) {
         FileChannel oplogFileChannel = oo.getFileChannel();
         try {
           oplogFileChannel.close();
@@ -295,14 +284,14 @@ public class OverflowOplogSet implements OplogSet {
   }
 
   ArrayList<OverflowOplog> testHookGetAllOverflowOplogs() {
-    ArrayList<OverflowOplog> result = new ArrayList<OverflowOplog>();
+    ArrayList<OverflowOplog> result = new ArrayList<>();
     synchronized (this.overflowMap) {
       for (OverflowOplog oo : this.overflowMap.values()) {
         result.add(oo);
       }
     }
-    synchronized (this.compactableOverflowMap) {
-      for (OverflowOplog oo : this.compactableOverflowMap.values()) {
+    synchronized (this.compactibleOverflowMap) {
+      for (OverflowOplog oo : this.compactibleOverflowMap.values()) {
         result.add(oo);
       }
     }
@@ -316,14 +305,13 @@ public class OverflowOplogSet implements OplogSet {
         oo.close();
       }
     }
-    synchronized (this.compactableOverflowMap) {
-      for (OverflowOplog oo : this.compactableOverflowMap.values()) {
+    synchronized (this.compactibleOverflowMap) {
+      for (OverflowOplog oo : this.compactibleOverflowMap.values()) {
         oo.close();
       }
     }
   }
 
-
   public DiskStoreImpl getParent() {
     return parent;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/PartitionedRegion.java b/geode-core/src/main/java/org/apache/geode/internal/cache/PartitionedRegion.java
index dcb31b4..7720bfa 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/PartitionedRegion.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/PartitionedRegion.java
@@ -7699,7 +7699,7 @@ public class PartitionedRegion extends LocalRegion
   }
 
   @Override
-  void dispatchListenerEvent(EnumListenerEvent op, InternalCacheEvent event) {
+  public void dispatchListenerEvent(EnumListenerEvent op, InternalCacheEvent event) {
     // don't dispatch the event if the interest policy forbids it
     if (hasListener()) {
       if (event.getOperation().isEntry()) {
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/PersistentOplogSet.java b/geode-core/src/main/java/org/apache/geode/internal/cache/PersistentOplogSet.java
index 8de7caa..a5ca6e9 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/PersistentOplogSet.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/PersistentOplogSet.java
@@ -179,12 +179,12 @@ public class PersistentOplogSet implements OplogSet {
   }
 
   @Override
-  public void create(LocalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
+  public void create(InternalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
     getChild().create(region, entry, value, async);
   }
 
   @Override
-  public void modify(LocalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
+  public void modify(InternalRegion region, DiskEntry entry, ValueWrapper value, boolean async) {
     getChild().modify(region, entry, value, async);
   }
 
@@ -194,7 +194,7 @@ public class PersistentOplogSet implements OplogSet {
   }
 
   @Override
-  public void remove(LocalRegion region, DiskEntry entry, boolean async, boolean isClear) {
+  public void remove(InternalRegion region, DiskEntry entry, boolean async, boolean isClear) {
     getChild().remove(region, entry, async, isClear);
   }
 
@@ -1035,9 +1035,6 @@ public class PersistentOplogSet implements OplogSet {
 
   /**
    * Add compactable oplogs to the list, up to the maximum size.
-   * 
-   * @param l
-   * @param max
    */
   public void getCompactableOplogs(List<CompactableOplog> l, int max) {
     synchronized (this.oplogIdToOplog) {
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/ProxyRegionMap.java b/geode-core/src/main/java/org/apache/geode/internal/cache/ProxyRegionMap.java
index 32de672..75c959f 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/ProxyRegionMap.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/ProxyRegionMap.java
@@ -69,34 +69,42 @@ class ProxyRegionMap implements RegionMap {
 
   private final Attributes attr;
 
+  @Override
   public RegionEntryFactory getEntryFactory() {
     throw new UnsupportedOperationException();
   }
 
+  @Override
   public Attributes getAttributes() {
     return this.attr;
   }
 
+  @Override
   public void setOwner(Object r) {
     throw new UnsupportedOperationException();
   }
 
+  @Override
   public void changeOwner(LocalRegion r) {
     throw new UnsupportedOperationException();
   }
 
+  @Override
   public int size() {
     return 0;
   }
 
+  @Override
   public boolean isEmpty() {
     return true;
   }
 
+  @Override
   public Set keySet() {
     return Collections.EMPTY_SET;
   }
 
+  @Override
   public Collection<RegionEntry> regionEntries() {
     return Collections.emptySet();
   }
@@ -106,18 +114,22 @@ class ProxyRegionMap implements RegionMap {
     return Collections.emptySet();
   }
 
+  @Override
   public boolean containsKey(Object key) {
     return false;
   }
 
+  @Override
   public RegionEntry getEntry(Object key) {
     return null;
   }
 
+  @Override
   public RegionEntry putEntryIfAbsent(Object key, RegionEntry re) {
     return null;
   }
 
+  @Override
   @SuppressWarnings({"rawtypes", "unchecked"})
   public Set<VersionSource> clear(RegionVersionVector rvv) {
     // nothing needs to be done
@@ -133,10 +145,12 @@ class ProxyRegionMap implements RegionMap {
     // nothing needs to be done
   }
 
+  @Override
   public RegionEntry initRecoveredEntry(Object key, DiskEntry.RecoveredEntry value) {
     throw new UnsupportedOperationException();
   }
 
+  @Override
   public RegionEntry updateRecoveredEntry(Object key, DiskEntry.RecoveredEntry value) {
     throw new UnsupportedOperationException();
   }
@@ -145,12 +159,14 @@ class ProxyRegionMap implements RegionMap {
    * Used to modify an existing RegionEntry or create a new one when processing the values obtained
    * during a getInitialImage.
    */
+  @Override
   public boolean initialImagePut(Object key, long lastModified, Object newValue,
-      boolean wasRecovered, boolean deferLRUCallback, VersionTag version,
+      boolean wasRecovered, boolean deferLRUCallback, VersionTag entryVersion,
       InternalDistributedMember sender, boolean forceValue) {
     throw new UnsupportedOperationException();
   }
 
+  @Override
   public boolean destroy(EntryEventImpl event, boolean inTokenMode, boolean duringRI,
       boolean cacheWrite, boolean isEviction, Object expectedOldValue, boolean removeRecoveredEntry)
       throws CacheWriterException, EntryNotFoundException, TimeoutException {
@@ -167,8 +183,9 @@ class ProxyRegionMap implements RegionMap {
     return true;
   }
 
+  @Override
   public boolean invalidate(EntryEventImpl event, boolean invokeCallbacks, boolean forceNewEntry,
-      boolean forceCallback) throws EntryNotFoundException {
+      boolean forceCallbacks) throws EntryNotFoundException {
 
     if (event.getOperation().isLocal()) {
       if (this.owner.isInitialized()) {
@@ -187,6 +204,7 @@ class ProxyRegionMap implements RegionMap {
     // noop
   }
 
+  @Override
   public void evictValue(Object key) {
     // noop
   }
@@ -196,6 +214,7 @@ class ProxyRegionMap implements RegionMap {
    */
   private static final RegionEntry markerEntry = new ProxyRegionEntry();
 
+  @Override
   public RegionEntry basicPut(EntryEventImpl event, long lastModified, boolean ifNew, boolean ifOld,
       Object expectedOldValue, boolean requireOldValue, boolean overwriteDestroyed)
       throws CacheWriterException, TimeoutException {
@@ -233,31 +252,34 @@ class ProxyRegionMap implements RegionMap {
     return markerEntry;
   }
 
+  @Override
   public void writeSyncIfPresent(Object key, Runnable runner) {
     // nothing needed
   }
 
+  @Override
   public void removeIfDestroyed(Object key) {
     // nothing needed
   }
 
-  public void txApplyDestroy(Object key, TransactionId txId, TXRmtEvent txEvent,
+  @Override
+  public void txApplyDestroy(Object key, TransactionId rmtOrigin, TXRmtEvent event,
       boolean inTokenMode, boolean inRI, Operation op, EventID eventId, Object aCallbackArgument,
       List<EntryEventImpl> pendingCallbacks, FilterRoutingInfo filterRoutingInfo,
-      ClientProxyMembershipID bridgeContext, boolean isOriginRemote, TXEntryState txEntryState,
+      ClientProxyMembershipID bridgeContext, boolean isOperationRemote, TXEntryState txEntryState,
       VersionTag versionTag, long tailKey) {
     this.owner.txApplyDestroyPart2(markerEntry, key, inTokenMode,
         false /* Clear conflict occurred */);
     if (!inTokenMode) {
-      if (txEvent != null) {
-        txEvent.addDestroy(this.owner, markerEntry, key, aCallbackArgument);
+      if (event != null) {
+        event.addDestroy(this.owner, markerEntry, key, aCallbackArgument);
       }
       if (AbstractRegionMap.shouldCreateCBEvent(this.owner, !inTokenMode)) {
         // fix for bug 39526
         @Released
-        EntryEventImpl e = AbstractRegionMap.createCBEvent(this.owner, op, key, null, txId, txEvent,
-            eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, txEntryState, versionTag,
-            tailKey);
+        EntryEventImpl e = AbstractRegionMap.createCBEvent(this.owner, op, key, null, rmtOrigin,
+            event, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, txEntryState,
+            versionTag, tailKey);
         boolean cbEventInPending = false;
         try {
           AbstractRegionMap.switchEventOwnerAndOriginRemote(e, txEntryState == null);
@@ -276,23 +298,24 @@ class ProxyRegionMap implements RegionMap {
     }
   }
 
-  public void txApplyInvalidate(Object key, Object newValue, boolean didDestroy, TransactionId txId,
-      TXRmtEvent txEvent, boolean localOp, EventID eventId, Object aCallbackArgument,
-      List<EntryEventImpl> pendingCallbacks, FilterRoutingInfo filterRoutingInfo,
-      ClientProxyMembershipID bridgeContext, TXEntryState txEntryState, VersionTag versionTag,
-      long tailKey) {
+  @Override
+  public void txApplyInvalidate(Object key, Object newValue, boolean didDestroy,
+      TransactionId rmtOrigin, TXRmtEvent event, boolean localOp, EventID eventId,
+      Object aCallbackArgument, List<EntryEventImpl> pendingCallbacks,
+      FilterRoutingInfo filterRoutingInfo, ClientProxyMembershipID bridgeContext,
+      TXEntryState txEntryState, VersionTag versionTag, long tailKey) {
     this.owner.txApplyInvalidatePart2(markerEntry, key, didDestroy, true);
     if (this.owner.isInitialized()) {
-      if (txEvent != null) {
-        txEvent.addInvalidate(this.owner, markerEntry, key, newValue, aCallbackArgument);
+      if (event != null) {
+        event.addInvalidate(this.owner, markerEntry, key, newValue, aCallbackArgument);
       }
       if (AbstractRegionMap.shouldCreateCBEvent(this.owner, this.owner.isInitialized())) {
         // fix for bug 39526
         boolean cbEventInPending = false;
         @Released
         EntryEventImpl e = AbstractRegionMap.createCBEvent(this.owner,
-            localOp ? Operation.LOCAL_INVALIDATE : Operation.INVALIDATE, key, newValue, txId,
-            txEvent, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, txEntryState,
+            localOp ? Operation.LOCAL_INVALIDATE : Operation.INVALIDATE, key, newValue, rmtOrigin,
+            event, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, txEntryState,
             versionTag, tailKey);
         try {
           AbstractRegionMap.switchEventOwnerAndOriginRemote(e, txEntryState == null);
@@ -311,26 +334,26 @@ class ProxyRegionMap implements RegionMap {
     }
   }
 
-  public void txApplyPut(Operation p_putOp, Object key, Object newValue, boolean didDestroy,
-      TransactionId txId, TXRmtEvent txEvent, EventID eventId, Object aCallbackArgument,
+  @Override
+  public void txApplyPut(Operation putOp, Object key, Object newValue, boolean didDestroy,
+      TransactionId rmtOrigin, TXRmtEvent event, EventID eventId, Object aCallbackArgument,
       List<EntryEventImpl> pendingCallbacks, FilterRoutingInfo filterRoutingInfo,
       ClientProxyMembershipID bridgeContext, TXEntryState txEntryState, VersionTag versionTag,
       long tailKey) {
-    Operation putOp = p_putOp.getCorrespondingCreateOp();
+    Operation putOperation = putOp.getCorrespondingCreateOp();
     long lastMod = owner.cacheTimeMillis();
-    this.owner.txApplyPutPart2(markerEntry, key, lastMod, true, didDestroy,
-        false /* Clear conflict occurred */);
+    this.owner.txApplyPutPart2(markerEntry, key, lastMod, true, didDestroy, false);
     if (this.owner.isInitialized()) {
-      if (txEvent != null) {
-        txEvent.addPut(putOp, this.owner, markerEntry, key, newValue, aCallbackArgument);
+      if (event != null) {
+        event.addPut(putOperation, this.owner, markerEntry, key, newValue, aCallbackArgument);
       }
       if (AbstractRegionMap.shouldCreateCBEvent(this.owner, this.owner.isInitialized())) {
         // fix for bug 39526
         boolean cbEventInPending = false;
         @Released
-        EntryEventImpl e = AbstractRegionMap.createCBEvent(this.owner, putOp, key, newValue, txId,
-            txEvent, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, txEntryState,
-            versionTag, tailKey);
+        EntryEventImpl e = AbstractRegionMap.createCBEvent(this.owner, putOperation, key, newValue,
+            rmtOrigin, event, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext,
+            txEntryState, versionTag, tailKey);
         try {
           AbstractRegionMap.switchEventOwnerAndOriginRemote(e, txEntryState == null);
           if (pendingCallbacks == null) {
@@ -349,15 +372,18 @@ class ProxyRegionMap implements RegionMap {
   }
 
   // LRUMapCallbacks methods
+  @Override
   public void lruUpdateCallback() {
     // nothing needed
   }
 
+  @Override
   public boolean disableLruUpdateCallback() {
     // nothing needed
     return false;
   }
 
+  @Override
   public void enableLruUpdateCallback() {
     // nothing needed
   }
@@ -372,20 +398,24 @@ class ProxyRegionMap implements RegionMap {
     return false;
   }
 
+  @Override
   public void lruCloseStats() {
     // nothing needed
   }
 
+  @Override
   public void resetThreadLocals() {
     // nothing needed
   }
 
-  public void removeEntry(Object key, RegionEntry entry, boolean updateStats) {
+  @Override
+  public void removeEntry(Object key, RegionEntry value, boolean updateStats) {
     // nothing to do
   }
 
+  @Override
   public void removeEntry(Object key, RegionEntry re, boolean updateStat, EntryEventImpl event,
-      LocalRegion owner) {
+      InternalRegion owner) {
     // nothing to do
   }
 
@@ -395,40 +425,47 @@ class ProxyRegionMap implements RegionMap {
    */
   public static class ProxyRegionEntry implements RegionEntry {
 
+    @Override
     public long getLastModified() {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public long getLastAccessed() throws InternalStatisticsDisabledException {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public long getHitCount() throws InternalStatisticsDisabledException {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public long getMissCount() throws InternalStatisticsDisabledException {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public VersionStamp getVersionStamp() {
       return null;
     }
 
+    @Override
     public boolean isTombstone() {
       return false;
     }
 
+    @Override
     public VersionTag generateVersionTag(VersionSource member, boolean withDelta,
-        LocalRegion region, EntryEventImpl event) {
+        InternalRegion region, EntryEventImpl event) {
       return null; // proxies don't do versioning
     }
 
@@ -436,77 +473,92 @@ class ProxyRegionMap implements RegionMap {
       return;
     }
 
-    public void makeTombstone(LocalRegion r, VersionTag isOperationRemote) {
+    @Override
+    public void makeTombstone(InternalRegion region, VersionTag version) {
       return;
     }
 
+    @Override
     public void updateStatsForPut(long lastModifiedTime, long lastAccessedTime) {
       // do nothing; called by LocalRegion.updateStatsForPut
     }
 
+    @Override
     public void setRecentlyUsed() {
       // do nothing; called by LocalRegion.updateStatsForPut
     }
 
+    @Override
     public void updateStatsForGet(boolean hit, long time) {
       // do nothing; no entry stats
     }
 
-    public void txDidDestroy(long currTime) {
+    @Override
+    public void txDidDestroy(long currentTime) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public void resetCounts() throws InternalStatisticsDisabledException {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    public void removePhase1(LocalRegion r, boolean isClear) {
+    @Override
+    public void removePhase1(InternalRegion region, boolean clear) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public void removePhase2() {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public boolean isRemoved() {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public boolean isRemovedPhase2() {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    public boolean fillInValue(LocalRegion r, Entry entry, ByteArrayDataInput in, DM mgr,
-        final Version version) {
+    @Override
+    public boolean fillInValue(InternalRegion region, Entry entry, ByteArrayDataInput in,
+        DM distributionManager, final Version version) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    public boolean isOverflowedToDisk(LocalRegion r, DistributedRegion.DiskPosition dp) {
+    @Override
+    public boolean isOverflowedToDisk(InternalRegion region,
+        DistributedRegion.DiskPosition diskPosition) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public Object getKey() {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public Object getValue(RegionEntryContext context) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
@@ -520,6 +572,7 @@ class ProxyRegionMap implements RegionMap {
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public void setValue(RegionEntryContext context, Object value) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
@@ -527,18 +580,13 @@ class ProxyRegionMap implements RegionMap {
     }
 
     @Override
-    public Object prepareValueForCache(RegionEntryContext r, Object val, boolean isEntryUpdate) {
+    public Object prepareValueForCache(RegionEntryContext context, Object value,
+        boolean isEntryUpdate) {
       throw new IllegalStateException("Should never be called");
     }
 
-    // @Override
-    // public void _setValue(Object value) {
-    // throw new
-    // UnsupportedOperationException(LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0.toLocalizedString(DataPolicy.EMPTY));
-    // }
-
     @Override
-    public Object _getValue() {
+    public Object getValue() {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
@@ -552,7 +600,7 @@ class ProxyRegionMap implements RegionMap {
     }
 
     @Override
-    public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+    public Object getValueRetain(RegionEntryContext context, boolean decompress) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
@@ -570,39 +618,45 @@ class ProxyRegionMap implements RegionMap {
       return null; // called by TXRmtEvent.createEvent
     }
 
-    public Object getValueOnDisk(LocalRegion r) throws EntryNotFoundException {
+    @Override
+    public Object getValueOnDisk(InternalRegion region) throws EntryNotFoundException {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    public Object getValueOnDiskOrBuffer(LocalRegion r) throws EntryNotFoundException {
+    @Override
+    public Object getValueOnDiskOrBuffer(InternalRegion region) throws EntryNotFoundException {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    public Object getSerializedValueOnDisk(LocalRegion localRegion) {
+    @Override
+    public Object getSerializedValueOnDisk(InternalRegion region) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    public boolean initialImagePut(LocalRegion region, long lastModified, Object newValue,
-        boolean wasRecovered, boolean versionTagAccepted) {
+    @Override
+    public boolean initialImagePut(InternalRegion region, long lastModified, Object newValue,
+        boolean wasRecovered, boolean acceptedVersionTag) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    public boolean initialImageInit(LocalRegion region, long lastModified, Object newValue,
-        boolean create, boolean wasRecovered, boolean versionTagAccepted) {
+    @Override
+    public boolean initialImageInit(InternalRegion region, long lastModified, Object newValue,
+        boolean create, boolean wasRecovered, boolean acceptedVersionTag) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    public boolean destroy(LocalRegion region, EntryEventImpl event, boolean inTokenMode,
+    @Override
+    public boolean destroy(InternalRegion region, EntryEventImpl event, boolean inTokenMode,
         boolean cacheWrite, Object expectedOldValue, boolean forceDestroy,
         boolean removeRecoveredEntry)
         throws CacheWriterException, EntryNotFoundException, TimeoutException {
@@ -611,56 +665,46 @@ class ProxyRegionMap implements RegionMap {
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public boolean getValueWasResultOfSearch() {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    public void setValueResultOfSearch(boolean v) {
+    @Override
+    public void setValueResultOfSearch(boolean value) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
+    @Override
     public boolean dispatchListenerEvents(EntryEventImpl event) throws InterruptedException {
-      // note that we don't synchronize on the RE before dispatching
-      // events
+      // note that we don't synchronize on the RE before dispatching events
       event.invokeCallbacks(event.getRegion(), event.inhibitCacheListenerNotification(), false);
       return true;
     }
 
+    @Override
     public boolean hasStats() {
       return false;
     }
 
-    public Object getValueInVMOrDiskWithoutFaultIn(LocalRegion owner) {
+    @Override
+    public Object getValueInVMOrDiskWithoutFaultIn(InternalRegion region) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
     @Override
-    public Object getValueOffHeapOrDiskWithoutFaultIn(LocalRegion owner) {
+    public Object getValueOffHeapOrDiskWithoutFaultIn(InternalRegion region) {
       throw new UnsupportedOperationException(
           LocalizedStrings.ProxyRegionMap_NO_ENTRY_SUPPORT_ON_REGIONS_WITH_DATAPOLICY_0
               .toLocalizedString(DataPolicy.EMPTY));
     }
 
-    /*
-     * (non-Javadoc)
-     * 
-     * @see
-     * org.apache.geode.internal.cache.RegionEntry#concurrencyCheck(org.apache.geode.internal.cache.
-     * LocalRegion, org.apache.geode.internal.cache.versions.VersionTag,
-     * org.apache.geode.distributed.internal.membership.InternalDistributedMember,
-     * org.apache.geode.distributed.internal.membership.InternalDistributedMember)
-     */
-    public void processVersionTag(LocalRegion r, VersionTag tag, InternalDistributedMember thisVM,
-        InternalDistributedMember sender) {
-      return;
-    }
-
     @Override
     public boolean isUpdateInProgress() {
       throw new UnsupportedOperationException(
@@ -726,8 +770,7 @@ class ProxyRegionMap implements RegionMap {
 
     @Override
     public void returnToPool() {
-      // TODO Auto-generated method stub
-
+      // nothing
     }
 
     @Override
@@ -740,14 +783,12 @@ class ProxyRegionMap implements RegionMap {
 
     @Override
     public boolean isCacheListenerInvocationInProgress() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public void setCacheListenerInvocationInProgress(boolean isListenerInvoked) {
-      // TODO Auto-generated method stub
-
+      // nothing
     }
 
     @Override
@@ -764,46 +805,58 @@ class ProxyRegionMap implements RegionMap {
     }
 
     @Override
-    public void setInUseByTransaction(boolean v) {}
+    public void setInUseByTransaction(boolean inUseByTransaction) {
+      // nothing
+    }
 
     @Override
     public void incRefCount() {}
 
     @Override
-    public void decRefCount(NewLRUClockHand lruList, LocalRegion lr) {}
+    public void decRefCount(NewLRUClockHand lruList, InternalRegion region) {
+      // nothing
+    }
 
     @Override
-    public void resetRefCount(NewLRUClockHand lruList) {}
+    public void resetRefCount(NewLRUClockHand lruList) {
+      // nothing
+    }
 
     @Override
-    public Object prepareValueForCache(RegionEntryContext r, Object val, EntryEventImpl event,
-        boolean isEntryUpdate) {
+    public Object prepareValueForCache(RegionEntryContext context, Object value,
+        EntryEventImpl event, boolean isEntryUpdate) {
       throw new IllegalStateException("Should never be called");
     }
   }
 
+  @Override
   public void lruUpdateCallback(int n) {
     // do nothing
   }
 
+  @Override
   public void lruEntryFaultIn(LRUEntry entry) {
     // do nothing.
 
   }
 
+  @Override
   public void copyRecoveredEntries(RegionMap rm) {
     throw new IllegalStateException("copyRecoveredEntries should never be called on proxy");
   }
 
+  @Override
   public boolean removeTombstone(RegionEntry re, VersionHolder destroyedVersion, boolean isEviction,
       boolean isScheduledTombstone) {
     throw new IllegalStateException("removeTombstone should never be called on a proxy");
   }
 
+  @Override
   public boolean isTombstoneNotNeeded(RegionEntry re, int destroyedVersion) {
     throw new IllegalStateException("removeTombstone should never be called on a proxy");
   }
 
+  @Override
   public void setEntryFactory(RegionEntryFactory f) {
     throw new IllegalStateException("Should not be called on a ProxyRegionMap");
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/RegionEntry.java b/geode-core/src/main/java/org/apache/geode/internal/cache/RegionEntry.java
index 3bf0bc0..8edbeac 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/RegionEntry.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/RegionEntry.java
@@ -12,7 +12,6 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-
 package org.apache.geode.internal.cache;
 
 import static org.apache.geode.internal.offheap.annotations.OffHeapIdentifier.ABSTRACT_REGION_ENTRY_FILL_IN_VALUE;
@@ -91,7 +90,7 @@ public interface RegionEntry {
    * @param event the event causing this change
    * @return a new version tag for this entry (null if versions not supported)
    */
-  VersionTag generateVersionTag(VersionSource member, boolean withDelta, LocalRegion region,
+  VersionTag generateVersionTag(VersionSource member, boolean withDelta, InternalRegion region,
       EntryEventImpl event);
 
   /**
@@ -113,31 +112,31 @@ public interface RegionEntry {
   /**
    * Resets any entry state as needed for a transaction that did a destroy to this entry.
    * 
-   * @param currTime Current Cache Time.
+   * @param currentTime Current Cache Time.
    */
-  void txDidDestroy(long currTime);
+  void txDidDestroy(long currentTime);
 
   void resetCounts() throws InternalStatisticsDisabledException;
 
   /**
    * this is done instead of removePhase2 if the entry needs to be kept for concurrency control
    * 
-   * @param r the region holding the entry
+   * @param region the region holding the entry
    * @param version whether the operation is from another member or local
    */
-  void makeTombstone(LocalRegion r, VersionTag version) throws RegionClearedException;
+  void makeTombstone(InternalRegion region, VersionTag version) throws RegionClearedException;
 
   /**
    * Mark this entry as being in the process of removal from the map that contains it by setting its
    * value to Token.REMOVED_PHASE1. An entry in this state may be resurrected by changing the value
    * under synchronization prior to the entry executing removePhase2.
-   * 
-   * @param r LocalRegion
+   *
+   * @param region the region
    * @param clear - if we removing this entry as a result of a region clear.
    * @throws RegionClearedException If operation got aborted due to a clear
    * 
    */
-  void removePhase1(LocalRegion r, boolean clear) throws RegionClearedException;
+  void removePhase1(InternalRegion region, boolean clear) throws RegionClearedException;
 
   /**
    * Mark this entry as having been removed from the map that contained it by setting its value to
@@ -177,15 +176,16 @@ public interface RegionEntry {
    *
    * @since GemFire 3.2.1
    */
-  boolean fillInValue(LocalRegion r, @Retained(ABSTRACT_REGION_ENTRY_FILL_IN_VALUE) Entry entry,
-      ByteArrayDataInput in, DM mgr, final Version version);
+  boolean fillInValue(InternalRegion region,
+      @Retained(ABSTRACT_REGION_ENTRY_FILL_IN_VALUE) Entry entry, ByteArrayDataInput in,
+      DM distributionManager, final Version version);
 
   /**
    * Returns true if this entry has overflowed to disk.
    * 
-   * @param dp if overflowed then the position of the value is set in dp
+   * @param diskPosition if overflowed then the position of the value is set in dp
    */
-  boolean isOverflowedToDisk(LocalRegion r, DistributedRegion.DiskPosition dp);
+  boolean isOverflowedToDisk(InternalRegion region, DistributedRegion.DiskPosition diskPosition);
 
   /**
    * Gets the key for this entry.
@@ -225,12 +225,13 @@ public interface RegionEntry {
    * @return possible OFF_HEAP_OBJECT (caller must release)
    */
   @Retained
-  Object _getValueRetain(RegionEntryContext context, boolean decompress);
-
-  /** Gets the value field of this entry. */
+  Object getValueRetain(RegionEntryContext context, boolean decompress);
 
+  /**
+   * Gets the value field of this entry.
+   */
   @Unretained
-  Object _getValue();
+  Object getValue();
 
   /**
    * Returns a tokenized form of the value. If the value can not be represented as a token then
@@ -263,34 +264,33 @@ public interface RegionEntry {
    * @return the value or EntryEvent.NOT_AVAILABLE token if it's not in the VM or null if the entry
    *         doesn't exist.
    *
-   * @see LocalRegion#getValueInVM
+   * @see InternalRegion#getValueInVM
    */
   Object getValueInVM(RegionEntryContext context);
 
   /**
    * Returns the value of an entry as it resides on disk. For testing purposes only.
    *
-   * @see LocalRegion#getValueOnDisk
+   * @see InternalRegion#getValueOnDisk
    */
-  Object getValueOnDisk(LocalRegion r) throws EntryNotFoundException;
+  Object getValueOnDisk(InternalRegion region) throws EntryNotFoundException;
 
   /**
    * Returns the value of an entry as it resides on buffer or disk. For asynch mode a value is not
    * immediately written to the disk & so checking in asynch buffers is needed .For testing purposes
    * only.
    *
-   * @see LocalRegion#getValueOnDisk
+   * @see InternalRegion#getValueOnDisk
    */
 
-  Object getValueOnDiskOrBuffer(LocalRegion r) throws EntryNotFoundException;
-
+  Object getValueOnDiskOrBuffer(InternalRegion region) throws EntryNotFoundException;
 
 
   /**
    * Used to modify an existing RegionEntry when processing the values obtained during a
    * getInitialImage.
    */
-  boolean initialImagePut(LocalRegion region, long lastModified, Object newValue,
+  boolean initialImagePut(InternalRegion region, long lastModified, Object newValue,
       boolean wasRecovered, boolean acceptedVersionTag) throws RegionClearedException;
 
   /**
@@ -313,8 +313,9 @@ public interface RegionEntry {
    * must write-synchronize to protect against puts from other<br>
    * threads running this method
    */
-  boolean initialImageInit(LocalRegion region, long lastModified, Object newValue, boolean create,
-      boolean wasRecovered, boolean acceptedVersionTag) throws RegionClearedException;
+  boolean initialImageInit(InternalRegion region, long lastModified, Object newValue,
+      boolean create, boolean wasRecovered, boolean acceptedVersionTag)
+      throws RegionClearedException;
 
   /**
    * @param expectedOldValue only succeed with destroy if current value is equal to expectedOldValue
@@ -323,8 +324,9 @@ public interface RegionEntry {
    * @return true if destroy was done; false if not
    */
   @Released
-  boolean destroy(LocalRegion region, EntryEventImpl event, boolean inTokenMode, boolean cacheWrite,
-      @Unretained Object expectedOldValue, boolean forceDestroy, boolean removeRecoveredEntry)
+  boolean destroy(InternalRegion region, EntryEventImpl event, boolean inTokenMode,
+      boolean cacheWrite, @Unretained Object expectedOldValue, boolean forceDestroy,
+      boolean removeRecoveredEntry)
       throws CacheWriterException, EntryNotFoundException, TimeoutException, RegionClearedException;
 
   /**
@@ -334,26 +336,26 @@ public interface RegionEntry {
   boolean getValueWasResultOfSearch();
 
   /**
-   * @param v true if entry's value should be marked as having been the result of a netsearch.
+   * @param value true if entry's value should be marked as having been the result of a netsearch.
    * @since GemFire 6.5
    */
-  void setValueResultOfSearch(boolean v);
+  void setValueResultOfSearch(boolean value);
 
   /**
    * Get the serialized bytes from disk. This method only looks for the value on the disk, ignoring
    * heap data.
    * 
-   * @param localRegion the persistent region
+   * @param region the persistent region
    * @return the serialized value from disk
    * @since GemFire 5.7
    */
-  Object getSerializedValueOnDisk(LocalRegion localRegion);
+  Object getSerializedValueOnDisk(InternalRegion region);
 
   /**
    * Gets the value for this entry. For DiskRegions, unlike {@link #getValue(RegionEntryContext)}
    * this will not fault in the value rather return a temporary copy.
    */
-  Object getValueInVMOrDiskWithoutFaultIn(LocalRegion owner);
+  Object getValueInVMOrDiskWithoutFaultIn(InternalRegion region);
 
   /**
    * Gets the value for this entry. For DiskRegions, unlike {@link #getValue(RegionEntryContext)}
@@ -361,7 +363,7 @@ public interface RegionEntry {
    * kept off heap (and compressed) if possible.
    */
   @Retained
-  Object getValueOffHeapOrDiskWithoutFaultIn(LocalRegion owner);
+  Object getValueOffHeapOrDiskWithoutFaultIn(InternalRegion region);
 
   /**
    * RegionEntry is underUpdate as soon as RegionEntry lock is help by an update thread to put a new
@@ -389,7 +391,7 @@ public interface RegionEntry {
 
   /**
    * Sets RegionEntry isCacheListenerInvoked flag when put is happening for a Region.Entry. Called
-   * ONLY in {@link LocalRegion#dispatchListenerEvent}.
+   * ONLY in {@link InternalRegion#dispatchListenerEvent}.
    */
   void setCacheListenerInvocationInProgress(final boolean isListenerInvoked);
 
@@ -435,7 +437,7 @@ public interface RegionEntry {
 
   boolean isInUseByTransaction();
 
-  void setInUseByTransaction(final boolean v);
+  void setInUseByTransaction(final boolean inUseByTransaction);
 
   /**
    * Increments the number of transactions that are currently referencing this node.
@@ -445,9 +447,9 @@ public interface RegionEntry {
   /**
    * Decrements the number of transactions that are currently referencing this node.
    * 
-   * @param lr the local region that owns this region entry; null if no local region owner
+   * @param region the local region that owns this region entry; null if no local region owner
    */
-  void decRefCount(NewLRUClockHand lruList, LocalRegion lr);
+  void decRefCount(NewLRUClockHand lruList, InternalRegion region);
 
   /**
    * Clear the number of transactions that are currently referencing this node and returns to LRU
@@ -456,9 +458,9 @@ public interface RegionEntry {
   void resetRefCount(NewLRUClockHand lruList);
 
   @Retained(ABSTRACT_REGION_ENTRY_PREPARE_VALUE_FOR_CACHE)
-  Object prepareValueForCache(RegionEntryContext r, Object val, boolean isEntryUpdate);
+  Object prepareValueForCache(RegionEntryContext context, Object value, boolean isEntryUpdate);
 
   @Retained(ABSTRACT_REGION_ENTRY_PREPARE_VALUE_FOR_CACHE)
-  Object prepareValueForCache(RegionEntryContext r, Object val, EntryEventImpl event,
+  Object prepareValueForCache(RegionEntryContext context, Object value, EntryEventImpl event,
       boolean isEntryUpdate);
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/RegionMap.java b/geode-core/src/main/java/org/apache/geode/internal/cache/RegionMap.java
index d10d3c6..45aafd7 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/RegionMap.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/RegionMap.java
@@ -12,7 +12,6 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-
 package org.apache.geode.internal.cache;
 
 import java.util.Collection;
@@ -40,8 +39,6 @@ import org.apache.geode.internal.cache.versions.VersionTag;
  * that the value of every entry in this map will implement {@link RegionEntry}.
  *
  * @since GemFire 3.5.1
- *
- *
  */
 public interface RegionMap extends LRUMapCallbacks {
 
@@ -49,7 +46,7 @@ public interface RegionMap extends LRUMapCallbacks {
    * Parameter object used to facilitate construction of an EntriesMap. Modification of fields after
    * the map is constructed has no effect.
    */
-  static class Attributes {
+  class Attributes {
     /**
      * The initial capacity. The implementation performs internal sizing to accommodate this many
      * elements.
@@ -67,99 +64,80 @@ public interface RegionMap extends LRUMapCallbacks {
 
     /** whether "api" statistics are enabled */
     boolean statisticsEnabled = false;
-
-    /** whether LRU stats are required */
-    // boolean lru = false;
   }
 
-  public RegionEntryFactory getEntryFactory();
+  RegionEntryFactory getEntryFactory();
 
   /**
    * This method should be called before region is initialized to ensure there is no mix of region
    * entries
    */
-  public void setEntryFactory(RegionEntryFactory f);
+  void setEntryFactory(RegionEntryFactory f);
 
   /**
    * Gets the attributes that this map was created with.
    */
-  public Attributes getAttributes();
+  Attributes getAttributes();
 
   /**
    * Tells this map what region owns it.
    */
-  public void setOwner(Object r);
+  void setOwner(Object r);
 
-  public void changeOwner(LocalRegion r);
+  void changeOwner(LocalRegion r);
 
-  public int size();
+  int size();
 
-  public boolean isEmpty();
+  boolean isEmpty();
 
   /**
    * @return number of entries cached in the backing CHM
    */
-  public int sizeInVM();
+  int sizeInVM();
 
-  public Set keySet();
+  Set keySet();
 
   /**
    * Returns a collection of RegionEntry instances.
    */
-  public Collection<RegionEntry> regionEntries();
+  Collection<RegionEntry> regionEntries();
 
   /**
    * Returns a collection of RegionEntry instances from memory only.
    */
-  public Collection<RegionEntry> regionEntriesInVM();
+  Collection<RegionEntry> regionEntriesInVM();
 
-  public boolean containsKey(Object key);
+  boolean containsKey(Object key);
 
   /**
    * fetches the entry from the backing ConcurrentHashMap
    * 
-   * @param key
    * @return the RegionEntry from memory or disk
    */
-  public RegionEntry getEntry(Object key);
+  RegionEntry getEntry(Object key);
 
-  public RegionEntry putEntryIfAbsent(Object key, RegionEntry re);
+  RegionEntry putEntryIfAbsent(Object key, RegionEntry re);
 
   /**
    * fetches the entry from the backing ConcurrentHashMap.
    * 
-   * @param key
    * @return the RegionEntry from memory
    */
-  public RegionEntry getEntryInVM(Object key);
+  RegionEntry getEntryInVM(Object key);
 
   /**
    * fetches the entry from the backing ConcurrentHashMap only if the entry is considered to be in
    * operational data i.e. does not have isMarkedForEviction() bit set.
    * 
-   * @param key
    * @return the RegionEntry in operational data
    */
-  public RegionEntry getOperationalEntryInVM(Object key);
-
-  // /**
-  // * Removes any entry associated with <code>key</code>.
-  // * Do nothing if the map has no entry for key.
-  // */
-  // public void remove(Object key);
-
-  // /**
-  // * Removes the entry associated with <code>key</code>
-  // * if it is <code>entry</code>.
-  // * Otherwise do nothing.
-  // */
-  // public void remove(Object key, RegionEntry entry);
+  RegionEntry getOperationalEntryInVM(Object key);
 
   /**
    * Clear the region and, if the parameter rvv is not null, return a collection of the IDs of
    * version sources that are still in the map when the operation completes.
    */
-  public Set<VersionSource> clear(RegionVersionVector rvv);
+  Set<VersionSource> clear(RegionVersionVector rvv);
 
   /**
    * Used by disk regions when recovering data from backup. Currently this "put" is done at a very
@@ -167,7 +145,7 @@ public interface RegionMap extends LRUMapCallbacks {
    * 
    * @return the created RegionEntry or null if entry already existed
    */
-  public RegionEntry initRecoveredEntry(Object key, DiskEntry.RecoveredEntry value);
+  RegionEntry initRecoveredEntry(Object key, DiskEntry.RecoveredEntry value);
 
   /**
    * Used by disk regions when recovering data from backup and initRecoveredEntry has already been
@@ -176,7 +154,7 @@ public interface RegionMap extends LRUMapCallbacks {
    * 
    * @return the updated RegionEntry
    */
-  public RegionEntry updateRecoveredEntry(Object key, DiskEntry.RecoveredEntry value);
+  RegionEntry updateRecoveredEntry(Object key, DiskEntry.RecoveredEntry value);
 
   /**
    * Used to modify an existing RegionEntry or create a new one when processing the values obtained
@@ -187,9 +165,9 @@ public interface RegionMap extends LRUMapCallbacks {
    * @param sender the sender of the initial image, if IIO. Not needed on clients
    * @param forceValue TODO
    */
-  public boolean initialImagePut(Object key, long lastModified, Object newValue,
-      boolean wasRecovered, boolean deferLRUCallback, VersionTag entryVersion,
-      InternalDistributedMember sender, boolean forceValue);
+  boolean initialImagePut(Object key, long lastModified, Object newValue, boolean wasRecovered,
+      boolean deferLRUCallback, VersionTag entryVersion, InternalDistributedMember sender,
+      boolean forceValue);
 
   /**
    * Destroy an entry the map.
@@ -208,8 +186,8 @@ public interface RegionMap extends LRUMapCallbacks {
    * @see CacheCallback
    * @see AbstractLRURegionMap
    */
-  public boolean destroy(EntryEventImpl event, boolean inTokenMode, boolean duringRI,
-      boolean cacheWrite, boolean isEviction, Object expectedOldValue, boolean removeRecoveredEntry)
+  boolean destroy(EntryEventImpl event, boolean inTokenMode, boolean duringRI, boolean cacheWrite,
+      boolean isEviction, Object expectedOldValue, boolean removeRecoveredEntry)
       throws CacheWriterException, EntryNotFoundException, TimeoutException;
 
   /**
@@ -220,10 +198,10 @@ public interface RegionMap extends LRUMapCallbacks {
    *        mode in that it doesn't leave an Invalid token in the cache.
    * @return true if invalidate was done
    */
-  public boolean invalidate(EntryEventImpl event, boolean invokeCallbacks, boolean forceNewEntry,
+  boolean invalidate(EntryEventImpl event, boolean invokeCallbacks, boolean forceNewEntry,
       boolean forceCallbacks) throws EntryNotFoundException;
 
-  public void evictValue(Object key);
+  void evictValue(Object key);
 
   /**
    * @param event the event object for this operation, with the exception that the oldValue
@@ -243,7 +221,7 @@ public interface RegionMap extends LRUMapCallbacks {
    *        because there is a DESTROYED token present then the entry flag blockedDestroyed is set.
    * @return null if put was not done; otherwise reference to put entry
    */
-  public RegionEntry basicPut(EntryEventImpl event, long lastModified, boolean ifNew, boolean ifOld,
+  RegionEntry basicPut(EntryEventImpl event, long lastModified, boolean ifNew, boolean ifOld,
       Object expectedOldValue, boolean requireOldValue, boolean overwriteDestroyed)
       throws CacheWriterException, TimeoutException;
 
@@ -251,13 +229,13 @@ public interface RegionMap extends LRUMapCallbacks {
    * Write synchronizes the given entry and invokes the runable while holding the lock. Does nothing
    * if the entry does not exist.
    */
-  public void writeSyncIfPresent(Object key, Runnable runner);
+  void writeSyncIfPresent(Object key, Runnable runner);
 
   /**
    * Remove the entry with the given key if it has been marked as destroyed This is currently used
    * in the cleanup phase of getInitialImage.
    */
-  public void removeIfDestroyed(Object key);
+  void removeIfDestroyed(Object key);
 
   /**
    * @param key the key of the entry to destroy
@@ -269,7 +247,6 @@ public interface RegionMap extends LRUMapCallbacks {
    * @param op the destroy operation to apply
    * @param eventId filled in if operation performed
    * @param aCallbackArgument callback argument passed by user
-   * @param filterRoutingInfo
    * @param isOperationRemote whether the operation is remote or originated here
    * @param txEntryState when not null, txEntryState.versionTag is set (used on near-side to pass
    *        versionTag to TXCommitMessage)
@@ -278,8 +255,8 @@ public interface RegionMap extends LRUMapCallbacks {
    * @param tailKey when not -1, it is the tailKey generated on near-side to be associated with
    *        entry on far-side for WAN
    */
-  public void txApplyDestroy(Object key, TransactionId rmtOrigin, TXRmtEvent event,
-      boolean inTokenMode, boolean inRI, Operation op, EventID eventId, Object aCallbackArgument,
+  void txApplyDestroy(Object key, TransactionId rmtOrigin, TXRmtEvent event, boolean inTokenMode,
+      boolean inRI, Operation op, EventID eventId, Object aCallbackArgument,
       List<EntryEventImpl> pendingCallbacks, FilterRoutingInfo filterRoutingInfo,
       ClientProxyMembershipID bridgeContext, boolean isOperationRemote, TXEntryState txEntryState,
       VersionTag versionTag, long tailKey);
@@ -292,7 +269,6 @@ public interface RegionMap extends LRUMapCallbacks {
    * @param event filled in if operation performed
    * @param localOp true for localInvalidates, false otherwise
    * @param aCallbackArgument callback argument passed by user
-   * @param filterRoutingInfo
    * @param txEntryState when not null, txEntryState.versionTag is set (used on near-side to pass
    *        versionTag to TXCommitMessage)
    * @param versionTag when not null, it is the tag generated on near-side to be associated with the
@@ -300,11 +276,11 @@ public interface RegionMap extends LRUMapCallbacks {
    * @param tailKey when not -1, it is the tailKey generated on near-side to be associated with
    *        entry on far-side for WAN
    */
-  public void txApplyInvalidate(Object key, Object newValue, boolean didDestroy,
-      TransactionId rmtOrigin, TXRmtEvent event, boolean localOp, EventID eventId,
-      Object aCallbackArgument, List<EntryEventImpl> pendingCallbacks,
-      FilterRoutingInfo filterRoutingInfo, ClientProxyMembershipID bridgeContext,
-      TXEntryState txEntryState, VersionTag versionTag, long tailKey);
+  void txApplyInvalidate(Object key, Object newValue, boolean didDestroy, TransactionId rmtOrigin,
+      TXRmtEvent event, boolean localOp, EventID eventId, Object aCallbackArgument,
+      List<EntryEventImpl> pendingCallbacks, FilterRoutingInfo filterRoutingInfo,
+      ClientProxyMembershipID bridgeContext, TXEntryState txEntryState, VersionTag versionTag,
+      long tailKey);
 
   /**
    * @param putOp describes the operation that did the put
@@ -314,7 +290,6 @@ public interface RegionMap extends LRUMapCallbacks {
    * @param rmtOrigin true if transaction being applied had a remote origin
    * @param event filled in if operation performed
    * @param aCallbackArgument callback argument passed by user
-   * @param filterRoutingInfo
    * @param txEntryState when not null, txEntryState.versionTag is set (used on near-side to pass
    *        versionTag to TXCommitMessage)
    * @param versionTag when not null, it is the tag generated on near-side to be associated with the
@@ -322,7 +297,7 @@ public interface RegionMap extends LRUMapCallbacks {
    * @param tailKey when not -1, it is the tailKey generated on near-side to be associated with
    *        entry on far-side for WAN
    */
-  public void txApplyPut(Operation putOp, Object key, Object newValue, boolean didDestroy,
+  void txApplyPut(Operation putOp, Object key, Object newValue, boolean didDestroy,
       TransactionId rmtOrigin, TXRmtEvent event, EventID eventId, Object aCallbackArgument,
       List<EntryEventImpl> pendingCallbacks, FilterRoutingInfo filterRoutingInfo,
       ClientProxyMembershipID bridgeContext, TXEntryState txEntryState, VersionTag versionTag,
@@ -331,16 +306,16 @@ public interface RegionMap extends LRUMapCallbacks {
   /**
    * removes the given key if the enclosing RegionEntry is still in this map
    */
-  public void removeEntry(Object key, RegionEntry value, boolean updateStats);
+  void removeEntry(Object key, RegionEntry value, boolean updateStats);
 
   /**
    * Removes the given key if the enclosing RegionEntry is still in this map for the given
    * EntryEvent
    */
-  public void removeEntry(Object key, RegionEntry re, boolean updateStat, EntryEventImpl event,
-      LocalRegion owner);
+  void removeEntry(Object key, RegionEntry re, boolean updateStat, EntryEventImpl event,
+      InternalRegion owner);
 
-  public void copyRecoveredEntries(RegionMap rm);
+  void copyRecoveredEntries(RegionMap rm);
 
   /**
    * Removes an entry that was previously destroyed and made into a tombstone.
@@ -351,7 +326,7 @@ public interface RegionMap extends LRUMapCallbacks {
    * @param isScheduledTombstone TODO
    * @return true if the tombstone entry was removed from the entry map
    */
-  public boolean removeTombstone(RegionEntry re, VersionHolder destroyedVersion, boolean isEviction,
+  boolean removeTombstone(RegionEntry re, VersionHolder destroyedVersion, boolean isEviction,
       boolean isScheduledTombstone);
 
   /**
@@ -361,22 +336,21 @@ public interface RegionMap extends LRUMapCallbacks {
    * @param destroyedVersion the version that was destroyed
    * @return true of the tombstone is no longer needed (entry was resurrected or evicted)
    */
-  public boolean isTombstoneNotNeeded(RegionEntry re, int destroyedVersion);
+  boolean isTombstoneNotNeeded(RegionEntry re, int destroyedVersion);
 
-  public void updateEntryVersion(EntryEventImpl event);
+  void updateEntryVersion(EntryEventImpl event);
 
   /**
    * Decrements the transaction reference count. Some features, like eviction and expiration, will
    * not modify an entry while it is referenced by a transaction.
    */
-  public void decTxRefCount(RegionEntry e);
+  void decTxRefCount(RegionEntry e);
 
-  public void close();
+  void close();
 
   default void lockRegionForAtomicTX(LocalRegion r) {}
 
   default void unlockRegionForAtomicTX(LocalRegion r) {}
 
-  public ARMLockTestHook getARMLockTestHook();
-
+  ARMLockTestHook getARMLockTestHook();
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/ValidatingDiskRegion.java b/geode-core/src/main/java/org/apache/geode/internal/cache/ValidatingDiskRegion.java
index 27dd75a..52c8f8c 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/ValidatingDiskRegion.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/ValidatingDiskRegion.java
@@ -69,14 +69,17 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
   private final ConcurrentMap<Object, DiskEntry> map = new ConcurrentHashMap<Object, DiskEntry>();
 
   ///////////// DiskRecoveryStore methods ////////////////
+  @Override
   public DiskRegionView getDiskRegionView() {
     return this;
   }
 
+  @Override
   public DiskEntry getDiskEntry(Object key) {
     return this.map.get(key);
   }
 
+  @Override
   public DiskEntry initializeRecoveredEntry(Object key, DiskEntry.RecoveredEntry re) {
     ValidatingDiskEntry de = new ValidatingDiskEntry(key, re);
     if (this.map.putIfAbsent(key, de) != null) {
@@ -86,30 +89,36 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
     return de;
   }
 
+  @Override
   public DiskEntry updateRecoveredEntry(Object key, DiskEntry.RecoveredEntry re) {
     ValidatingDiskEntry de = new ValidatingDiskEntry(key, re);
     this.map.put(key, de);
     return de;
   }
 
+  @Override
   public void destroyRecoveredEntry(Object key) {
     this.map.remove(key);
   }
 
+  @Override
   public void foreachRegionEntry(LocalRegion.RegionEntryCallback callback) {
     throw new IllegalStateException(
         "foreachRegionEntry should not be called when validating disk store");
   }
 
+  @Override
   public boolean lruLimitExceeded() {
     return false;
   }
 
+  @Override
   public void copyRecoveredEntries(RegionMap rm) {
     throw new IllegalStateException(
         "copyRecoveredEntries should not be called on ValidatingDiskRegion");
   }
 
+  @Override
   public void updateSizeOnFaultIn(Object key, int newSize, int bytesOnDisk) {
     throw new IllegalStateException(
         "updateSizeOnFaultIn should not be called on ValidatingDiskRegion");
@@ -125,15 +134,18 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
     return 0;
   }
 
+  @Override
   public RegionMap getRegionMap() {
     throw new IllegalStateException("getRegionMap should not be called on ValidatingDiskRegion");
   }
 
+  @Override
   public void handleDiskAccessException(DiskAccessException dae) {
     throw new IllegalStateException(
         "handleDiskAccessException should not be called on ValidatingDiskRegion");
   }
 
+  @Override
   public void initializeStats(long numEntriesInVM, long numOverflowOnDisk,
       long numOverflowBytesOnDisk) {
     throw new IllegalStateException("initializeStats should not be called on ValidatingDiskRegion");
@@ -157,11 +169,13 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
       this.diskId.setValueLength(re.getValueLength());
     }
 
+    @Override
     public Object getKey() {
       return this.key;
     }
 
-    public Object _getValue() {
+    @Override
+    public Object getValue() {
       return null;
     }
 
@@ -170,10 +184,12 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
       return null;
     }
 
-    public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+    @Override
+    public Object getValueRetain(RegionEntryContext context, boolean decompress) {
       return null;
     }
 
+    @Override
     public boolean isValueNull() {
       throw new IllegalStateException("should never be called");
     }
@@ -193,7 +209,8 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
     }
 
     @Override
-    public Object prepareValueForCache(RegionEntryContext r, Object val, boolean isEntryUpdate) {
+    public Object prepareValueForCache(RegionEntryContext context, Object value,
+        boolean isEntryUpdate) {
       throw new IllegalStateException("Should never be called");
     }
 
@@ -201,30 +218,37 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
       throw new IllegalStateException("should never be called");
     }
 
+    @Override
     public DiskId getDiskId() {
       return this.diskId;
     }
 
+    @Override
     public long getLastModified() {
       throw new IllegalStateException("should never be called");
     }
 
+    @Override
     public int updateAsyncEntrySize(EnableLRU capacityController) {
       throw new IllegalStateException("should never be called");
     }
 
+    @Override
     public DiskEntry getPrev() {
       throw new IllegalStateException("should never be called");
     }
 
+    @Override
     public DiskEntry getNext() {
       throw new IllegalStateException("should never be called");
     }
 
+    @Override
     public void setPrev(DiskEntry v) {
       throw new IllegalStateException("should never be called");
     }
 
+    @Override
     public void setNext(DiskEntry v) {
       throw new IllegalStateException("should never be called");
     }
@@ -236,7 +260,6 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
      */
     @Override
     public VersionStamp getVersionStamp() {
-      // TODO Auto-generated method stub
       return null;
     }
 
@@ -247,115 +270,104 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
 
     @Override
     public boolean hasStats() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public long getLastAccessed() throws InternalStatisticsDisabledException {
-      // TODO Auto-generated method stub
       return 0;
     }
 
     @Override
     public long getHitCount() throws InternalStatisticsDisabledException {
-      // TODO Auto-generated method stub
       return 0;
     }
 
     @Override
     public long getMissCount() throws InternalStatisticsDisabledException {
-      // TODO Auto-generated method stub
       return 0;
     }
 
     @Override
     public void updateStatsForPut(long lastModifiedTime, long lastAccessedTime) {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public VersionTag generateVersionTag(VersionSource member, boolean withDelta,
-        LocalRegion region, EntryEventImpl event) {
-      // TODO Auto-generated method stub
+        InternalRegion region, EntryEventImpl event) {
       return null;
     }
 
     @Override
     public boolean dispatchListenerEvents(EntryEventImpl event) throws InterruptedException {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public void setRecentlyUsed() {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public void updateStatsForGet(boolean hit, long time) {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
-    public void txDidDestroy(long currTime) {
-      // TODO Auto-generated method stub
+    public void txDidDestroy(long currentTime) {
+      // Tnothing
     }
 
     @Override
     public void resetCounts() throws InternalStatisticsDisabledException {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
-    public void makeTombstone(LocalRegion r, VersionTag version) throws RegionClearedException {
-      // TODO Auto-generated method stub
+    public void makeTombstone(InternalRegion region, VersionTag version)
+        throws RegionClearedException {
+      // nothing
     }
 
     @Override
-    public void removePhase1(LocalRegion r, boolean clear) throws RegionClearedException {
-      // TODO Auto-generated method stub
+    public void removePhase1(InternalRegion region, boolean clear) throws RegionClearedException {
+      // nothing
     }
 
     @Override
     public void removePhase2() {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public boolean isRemoved() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isRemovedPhase2() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isTombstone() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
-    public boolean fillInValue(LocalRegion r, Entry entry, ByteArrayDataInput in, DM mgr,
-        final Version version) {
-      // TODO Auto-generated method stub
+    public boolean fillInValue(InternalRegion region, Entry entry, ByteArrayDataInput in,
+        DM distributionManager, final Version version) {
       return false;
     }
 
     @Override
-    public boolean isOverflowedToDisk(LocalRegion r, DiskPosition dp) {
-      // TODO Auto-generated method stub
+    public boolean isOverflowedToDisk(InternalRegion region, DiskPosition diskPosition) {
       return false;
     }
 
     @Override
     public Object getValue(RegionEntryContext context) {
-      // TODO Auto-generated method stub
       return null;
     }
 
@@ -366,153 +378,134 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
 
     @Override
     public void setValue(RegionEntryContext context, Object value) throws RegionClearedException {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public void setValueWithTombstoneCheck(Object value, EntryEvent event)
         throws RegionClearedException {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public Object getTransformedValue() {
-      // TODO Auto-generated method stub
       return null;
     }
 
     @Override
     public Object getValueInVM(RegionEntryContext context) {
-      // TODO Auto-generated method stub
       return null;
     }
 
     @Override
-    public Object getValueOnDisk(LocalRegion r) throws EntryNotFoundException {
-      // TODO Auto-generated method stub
+    public Object getValueOnDisk(InternalRegion region) throws EntryNotFoundException {
       return null;
     }
 
     @Override
-    public Object getValueOnDiskOrBuffer(LocalRegion r) throws EntryNotFoundException {
-      // TODO Auto-generated method stub
+    public Object getValueOnDiskOrBuffer(InternalRegion region) throws EntryNotFoundException {
       return null;
     }
 
     @Override
-    public boolean initialImagePut(LocalRegion region, long lastModified, Object newValue,
+    public boolean initialImagePut(InternalRegion region, long lastModified, Object newValue,
         boolean wasRecovered, boolean acceptedVersionTag) throws RegionClearedException {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
-    public boolean initialImageInit(LocalRegion region, long lastModified, Object newValue,
+    public boolean initialImageInit(InternalRegion region, long lastModified, Object newValue,
         boolean create, boolean wasRecovered, boolean acceptedVersionTag)
         throws RegionClearedException {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
-    public boolean destroy(LocalRegion region, EntryEventImpl event, boolean inTokenMode,
+    public boolean destroy(InternalRegion region, EntryEventImpl event, boolean inTokenMode,
         boolean cacheWrite, Object expectedOldValue, boolean forceDestroy,
         boolean removeRecoveredEntry) throws CacheWriterException, EntryNotFoundException,
         TimeoutException, RegionClearedException {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean getValueWasResultOfSearch() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
-    public void setValueResultOfSearch(boolean v) {
-      // TODO Auto-generated method stub
+    public void setValueResultOfSearch(boolean value) {
+      // nothing
     }
 
     @Override
-    public Object getSerializedValueOnDisk(LocalRegion localRegion) {
-      // TODO Auto-generated method stub
+    public Object getSerializedValueOnDisk(InternalRegion region) {
       return null;
     }
 
     @Override
-    public Object getValueInVMOrDiskWithoutFaultIn(LocalRegion owner) {
-      // TODO Auto-generated method stub
+    public Object getValueInVMOrDiskWithoutFaultIn(InternalRegion region) {
       return null;
     }
 
     @Override
-    public Object getValueOffHeapOrDiskWithoutFaultIn(LocalRegion owner) {
-      // TODO Auto-generated method stub
+    public Object getValueOffHeapOrDiskWithoutFaultIn(InternalRegion region) {
       return null;
     }
 
     @Override
     public boolean isUpdateInProgress() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public void setUpdateInProgress(boolean underUpdate) {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public boolean isInvalid() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isDestroyed() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isDestroyedOrRemoved() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isDestroyedOrRemovedButNotTombstone() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public boolean isInvalidOrRemoved() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public void setValueToNull() {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public void returnToPool() {
-      // TODO Auto-generated method stub
+      // nothing
     }
 
     @Override
     public boolean isCacheListenerInvocationInProgress() {
-      // TODO Auto-generated method stub
       return false;
     }
 
     @Override
     public void setCacheListenerInvocationInProgress(boolean isListenerInvoked) {
-      // TODO Auto-generated method stub
-
+      // nothing
     }
 
     @Override
@@ -525,20 +518,28 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
     }
 
     @Override
-    public void setInUseByTransaction(boolean v) {}
+    public void setInUseByTransaction(boolean inUseByTransaction) {
+      // nothing
+    }
 
     @Override
-    public void incRefCount() {}
+    public void incRefCount() {
+      // nothing
+    }
 
     @Override
-    public void decRefCount(NewLRUClockHand lruList, LocalRegion lr) {}
+    public void decRefCount(NewLRUClockHand lruList, InternalRegion region) {
+      // nothing
+    }
 
     @Override
-    public void resetRefCount(NewLRUClockHand lruList) {}
+    public void resetRefCount(NewLRUClockHand lruList) {
+      // nothing
+    }
 
     @Override
-    public Object prepareValueForCache(RegionEntryContext r, Object val, EntryEventImpl event,
-        boolean isEntryUpdate) {
+    public Object prepareValueForCache(RegionEntryContext context, Object value,
+        EntryEventImpl event, boolean isEntryUpdate) {
       throw new IllegalStateException("Should never be called");
     }
   }
@@ -547,6 +548,7 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
   //////////////// DiskExceptionHandler methods ////////////////////
 
   public static class DummyDiskExceptionHandler implements DiskExceptionHandler {
+    @Override
     public void handleDiskAccessException(DiskAccessException dae) {
       // nothing needed
     }
@@ -564,8 +566,8 @@ public class ValidatingDiskRegion extends DiskRegion implements DiskRecoveryStor
     }
 
     @Override
-    public RuntimeException generateCancelledException(Throwable e) {
-      return new RuntimeException(e);
+    public RuntimeException generateCancelledException(Throwable throwable) {
+      return new RuntimeException(throwable);
     }
 
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractDiskRegionEntry.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractDiskRegionEntry.java
index 185d22c..763133e 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractDiskRegionEntry.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractDiskRegionEntry.java
@@ -60,7 +60,7 @@ public abstract class AbstractDiskRegionEntry extends AbstractRegionEntry implem
   public void handleValueOverflow(RegionEntryContext context) {
     if (context instanceof BucketRegionQueue
         || context instanceof SerialGatewaySenderQueue.SerialGatewaySenderQueueMetaRegion) {
-      GatewaySenderEventImpl.release(this._getValue()); // OFFHEAP _getValue ok
+      GatewaySenderEventImpl.release(this.getValue()); // OFFHEAP _getValue ok
     }
   }
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractOplogDiskRegionEntry.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractOplogDiskRegionEntry.java
index 6a70521..f7b76c8 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractOplogDiskRegionEntry.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractOplogDiskRegionEntry.java
@@ -23,7 +23,7 @@ import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DistributedRegion;
 import org.apache.geode.internal.cache.EntryBits;
 import org.apache.geode.internal.cache.InitialImageOperation.Entry;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.RegionClearedException;
 import org.apache.geode.internal.cache.RegionEntry;
 import org.apache.geode.internal.cache.RegionEntryContext;
@@ -45,9 +45,9 @@ public abstract class AbstractOplogDiskRegionEntry extends AbstractDiskRegionEnt
   public abstract void setDiskId(RegionEntry oldRe);
 
   @Override
-  public void removePhase1(LocalRegion r, boolean isClear) throws RegionClearedException {
+  public void removePhase1(InternalRegion region, boolean clear) throws RegionClearedException {
     synchronized (this) {
-      Helper.removeFromDisk(this, r, isClear);
+      Helper.removeFromDisk(this, region, clear);
       _removePhase1();
     }
   }
@@ -64,67 +64,72 @@ public abstract class AbstractOplogDiskRegionEntry extends AbstractDiskRegionEnt
   }
 
   @Override
-  public boolean fillInValue(LocalRegion r, Entry entry, ByteArrayDataInput in, DM mgr,
+  public boolean fillInValue(InternalRegion region, Entry entry, ByteArrayDataInput in, DM mgr,
       final Version version) {
-    return Helper.fillInValue(this, entry, r.getDiskRegion(), mgr, in, r, version);
+    return Helper.fillInValue(this, entry, region.getDiskRegion(), mgr, in, region, version);
   }
 
   @Override
-  public boolean isOverflowedToDisk(LocalRegion r, DistributedRegion.DiskPosition dp) {
-    return Helper.isOverflowedToDisk(this, r.getDiskRegion(), dp, r);
+  public boolean isOverflowedToDisk(InternalRegion region,
+      DistributedRegion.DiskPosition diskPosition) {
+    return Helper.isOverflowedToDisk(this, region.getDiskRegion(), diskPosition, region);
   }
 
   @Override
   public Object getValue(RegionEntryContext context) {
-    return Helper.faultInValue(this, (LocalRegion) context); // OFFHEAP returned to callers
+    return Helper.faultInValue(this, (InternalRegion) context); // OFFHEAP returned to callers
   }
 
   @Override
   @Retained
   public Object getValueRetain(RegionEntryContext context) {
-    return Helper.faultInValueRetain(this, (LocalRegion) context);
+    return Helper.faultInValueRetain(this, (InternalRegion) context);
   }
 
   @Override
-  public Object getValueInVMOrDiskWithoutFaultIn(LocalRegion owner) {
-    return Helper.getValueInVMOrDiskWithoutFaultIn(this, owner);
+  public Object getValueInVMOrDiskWithoutFaultIn(InternalRegion region) {
+    return Helper.getValueInVMOrDiskWithoutFaultIn(this, region);
   }
 
   @Retained
   @Override
-  public Object getValueOffHeapOrDiskWithoutFaultIn(LocalRegion owner) {
-    return Helper.getValueOffHeapOrDiskWithoutFaultIn(this, owner);
+  public Object getValueOffHeapOrDiskWithoutFaultIn(InternalRegion region) {
+    return Helper.getValueOffHeapOrDiskWithoutFaultIn(this, region);
   }
 
   @Override
-  public Object getValueOnDisk(LocalRegion r) throws EntryNotFoundException {
-    return Helper.getValueOnDisk(this, r.getDiskRegion());
+  public Object getValueOnDisk(InternalRegion region) throws EntryNotFoundException {
+    return Helper.getValueOnDisk(this, region.getDiskRegion());
   }
 
   @Override
-  public Object getSerializedValueOnDisk(LocalRegion r) throws EntryNotFoundException {
-    return Helper.getSerializedValueOnDisk(this, r.getDiskRegion());
+  public Object getSerializedValueOnDisk(InternalRegion region) throws EntryNotFoundException {
+    return Helper.getSerializedValueOnDisk(this, region.getDiskRegion());
   }
 
   @Override
-  public Object getValueOnDiskOrBuffer(LocalRegion r) throws EntryNotFoundException {
+  public Object getValueOnDiskOrBuffer(InternalRegion region) throws EntryNotFoundException {
     // @todo darrel if value is Token.REMOVED || Token.DESTROYED throw
     // EntryNotFoundException
-    return Helper.getValueOnDiskOrBuffer(this, r.getDiskRegion(), r);
+    return Helper.getValueOnDiskOrBuffer(this, region.getDiskRegion(), region);
   }
 
+  @Override
   public DiskEntry getPrev() {
     return getDiskId().getPrev();
   }
 
+  @Override
   public DiskEntry getNext() {
     return getDiskId().getNext();
   }
 
+  @Override
   public void setPrev(DiskEntry v) {
     getDiskId().setPrev(v);
   }
 
+  @Override
   public void setNext(DiskEntry v) {
     getDiskId().setNext(v);
   }
@@ -134,7 +139,7 @@ public abstract class AbstractOplogDiskRegionEntry extends AbstractDiskRegionEnt
    * tag
    */
   @Override
-  public void persistConflictingTag(LocalRegion region, VersionTag tag) {
+  public void persistConflictingTag(InternalRegion region, VersionTag tag) {
     // only persist region needs to persist conflict tag
     Helper.updateVersionOnly(this, region, tag);
     setRecentlyUsed();
@@ -149,7 +154,7 @@ public abstract class AbstractOplogDiskRegionEntry extends AbstractDiskRegionEnt
     DiskId did = getDiskId();
     boolean checkConflicts = true;
     if (did != null) {
-      LocalRegion lr = (LocalRegion) cacheEvent.getRegion();
+      InternalRegion lr = (InternalRegion) cacheEvent.getRegion();
       if (lr != null && lr.getDiskRegion().isReadyForRecovery()) {
         synchronized (did) {
           checkConflicts = !EntryBits.isRecoveredFromDisk(did.getUserBits());
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractRegionEntry.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractRegionEntry.java
index dfe8148..22cd4e8 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractRegionEntry.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/AbstractRegionEntry.java
@@ -54,7 +54,7 @@ import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.Version;
 import org.apache.geode.internal.cache.InternalCache;
 import org.apache.geode.internal.cache.InternalCacheEvent;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.RegionClearedException;
 import org.apache.geode.internal.cache.RegionEntry;
 import org.apache.geode.internal.cache.RegionEntryContext;
@@ -65,6 +65,7 @@ import org.apache.geode.internal.cache.Token;
 import org.apache.geode.internal.cache.TombstoneService;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.persistence.DiskStoreID;
 import org.apache.geode.internal.cache.versions.ConcurrentCacheModificationException;
 import org.apache.geode.internal.cache.versions.RegionVersionVector;
@@ -148,7 +149,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   @Override
   @SuppressWarnings("IMSE_DONT_CATCH_IMSE")
   public boolean dispatchListenerEvents(final EntryEventImpl event) throws InterruptedException {
-    final LocalRegion rgn = event.getRegion();
+    final InternalRegion rgn = event.getRegion();
 
     if (event.callbacksInvoked()) {
       return true;
@@ -177,7 +178,8 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
         // by the RegionMap. It is unclear why this code is needed. ARM destroy
         // does this also and we are now doing it as phase3 of the ARM destroy.
         removePhase2();
-        rgn.getRegionMap().removeEntry(event.getKey(), this, true, event, rgn);
+        ((DiskRecoveryStore) rgn).getRegionMap().removeEntry(event.getKey(), this, true, event,
+            rgn);
       }
     }
   }
@@ -220,8 +222,8 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModifiedAndAccessedTimes(currTime, currTime);
+  public void txDidDestroy(long currentTime) {
+    setLastModifiedAndAccessedTimes(currentTime, currentTime);
   }
 
   @Override
@@ -249,7 +251,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   @Override
-  public void removePhase1(LocalRegion r, boolean clear) throws RegionClearedException {
+  public void removePhase1(InternalRegion region, boolean clear) throws RegionClearedException {
     _removePhase1();
   }
 
@@ -259,37 +261,38 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   @Override
-  public void makeTombstone(LocalRegion r, VersionTag version) throws RegionClearedException {
-    assert r.getVersionVector() != null;
+  public void makeTombstone(InternalRegion region, VersionTag version)
+      throws RegionClearedException {
+    assert region.getVersionVector() != null;
     assert version != null;
-    if (r.getServerProxy() == null && r.getVersionVector().isTombstoneTooOld(version.getMemberID(),
-        version.getRegionVersion())) {
+    if (region.getServerProxy() == null && region.getVersionVector()
+        .isTombstoneTooOld(version.getMemberID(), version.getRegionVersion())) {
       // distributed gc with higher vector version preempts this operation
       if (!isTombstone()) {
-        basicMakeTombstone(r);
-        r.incTombstoneCount(1);
+        basicMakeTombstone(region);
+        region.getCachePerfStats().incTombstoneCount(1);
       }
-      r.getRegionMap().removeTombstone(this, version, false, true);
+      ((DiskRecoveryStore) region).getRegionMap().removeTombstone(this, version, false, true);
     } else {
       if (isTombstone()) {
         // unschedule the old tombstone
-        r.unscheduleTombstone(this);
+        region.unscheduleTombstone(this);
       }
       setRecentlyUsed();
       boolean newEntry = getValueAsToken() == Token.REMOVED_PHASE1;
-      basicMakeTombstone(r);
-      r.scheduleTombstone(this, version);
+      basicMakeTombstone(region);
+      region.scheduleTombstone(this, version);
       if (newEntry) {
         // bug #46631 - entry count is decremented by scheduleTombstone but this is a new entry
-        r.getCachePerfStats().incEntryCount(1);
+        region.getCachePerfStats().incEntryCount(1);
       }
     }
   }
 
-  private void basicMakeTombstone(LocalRegion r) throws RegionClearedException {
+  private void basicMakeTombstone(InternalRegion region) throws RegionClearedException {
     boolean setValueCompleted = false;
     try {
-      setValue(r, Token.TOMBSTONE);
+      setValue(region, Token.TOMBSTONE);
       setValueCompleted = true;
     } finally {
       if (!setValueCompleted && isTombstone()) {
@@ -302,7 +305,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   public void setValueWithTombstoneCheck(@Unretained Object v, EntryEvent e)
       throws RegionClearedException {
     if (v == Token.TOMBSTONE) {
-      makeTombstone((LocalRegion) e.getRegion(), ((InternalCacheEvent) e).getVersionTag());
+      makeTombstone((InternalRegion) e.getRegion(), ((InternalCacheEvent) e).getVersionTag());
     } else {
       setValue((RegionEntryContext) e.getRegion(), v, (EntryEventImpl) e);
     }
@@ -344,7 +347,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   @Override
-  public boolean fillInValue(LocalRegion region,
+  public boolean fillInValue(InternalRegion region,
       @Retained(ABSTRACT_REGION_ENTRY_FILL_IN_VALUE) Entry entry, ByteArrayDataInput in, DM mgr,
       final Version version) {
 
@@ -435,7 +438,8 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   @Override
-  public boolean isOverflowedToDisk(LocalRegion r, DistributedRegion.DiskPosition dp) {
+  public boolean isOverflowedToDisk(InternalRegion region,
+      DistributedRegion.DiskPosition diskPosition) {
     return false;
   }
 
@@ -443,7 +447,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   public Object getValue(RegionEntryContext context) {
     ReferenceCountHelper.createReferenceCountOwner();
     @Retained
-    Object result = _getValueRetain(context, true);
+    Object result = getValueRetain(context, true);
 
     // If the thread is an Index Creation Thread & the value obtained is
     // Token.REMOVED , we can skip synchronization block. This is required to prevent
@@ -468,7 +472,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   @Retained
   public Object getValueRetain(RegionEntryContext context) {
     @Retained
-    Object result = _getValueRetain(context, true);
+    Object result = getValueRetain(context, true);
     if (Token.isRemoved(result)) {
       return null;
     } else {
@@ -510,8 +514,8 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   private boolean isThisRegionBeingClosedOrDestroyed(RegionEntryContext context) {
-    return context instanceof LocalRegion
-        && ((LocalRegion) context).isThisRegionBeingClosedOrDestroyed();
+    return context instanceof InternalRegion
+        && ((InternalRegion) context).isThisRegionBeingClosedOrDestroyed();
   }
 
   private boolean isOffHeapReference(Object ref) {
@@ -608,7 +612,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   public Object getValueInVM(RegionEntryContext context) {
     ReferenceCountHelper.createReferenceCountOwner();
     @Released
-    Object v = _getValueRetain(context, true);
+    Object v = getValueRetain(context, true);
 
     if (v == null) {
       // should only be possible if disk entry
@@ -620,27 +624,27 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   @Override
-  public Object getValueInVMOrDiskWithoutFaultIn(LocalRegion owner) {
-    return getValueInVM(owner);
+  public Object getValueInVMOrDiskWithoutFaultIn(InternalRegion region) {
+    return getValueInVM(region);
   }
 
   @Override
   @Retained
-  public Object getValueOffHeapOrDiskWithoutFaultIn(LocalRegion owner) {
+  public Object getValueOffHeapOrDiskWithoutFaultIn(InternalRegion region) {
     @Retained
-    Object result = _getValueRetain(owner, true);
+    Object result = getValueRetain(region, true);
     return result;
   }
 
   @Override
-  public Object getValueOnDisk(LocalRegion r) throws EntryNotFoundException {
+  public Object getValueOnDisk(InternalRegion region) throws EntryNotFoundException {
     throw new IllegalStateException(
         LocalizedStrings.AbstractRegionEntry_CANNOT_GET_VALUE_ON_DISK_FOR_A_REGION_THAT_DOES_NOT_ACCESS_THE_DISK
             .toLocalizedString());
   }
 
   @Override
-  public Object getSerializedValueOnDisk(final LocalRegion localRegion)
+  public Object getSerializedValueOnDisk(final InternalRegion region)
       throws EntryNotFoundException {
     throw new IllegalStateException(
         LocalizedStrings.AbstractRegionEntry_CANNOT_GET_VALUE_ON_DISK_FOR_A_REGION_THAT_DOES_NOT_ACCESS_THE_DISK
@@ -648,7 +652,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   @Override
-  public Object getValueOnDiskOrBuffer(LocalRegion r) throws EntryNotFoundException {
+  public Object getValueOnDiskOrBuffer(InternalRegion region) throws EntryNotFoundException {
     throw new IllegalStateException(
         LocalizedStrings.AbstractRegionEntry_CANNOT_GET_VALUE_ON_DISK_FOR_A_REGION_THAT_DOES_NOT_ACCESS_THE_DISK
             .toLocalizedString());
@@ -656,15 +660,16 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   @Override
-  public boolean initialImagePut(final LocalRegion region, final long lastModified, Object newValue,
-      boolean wasRecovered, boolean acceptedVersionTag) throws RegionClearedException {
+  public boolean initialImagePut(final InternalRegion region, final long lastModified,
+      Object newValue, boolean wasRecovered, boolean acceptedVersionTag)
+      throws RegionClearedException {
     // note that the caller has already write synced this RegionEntry
     return initialImageInit(region, lastModified, newValue, this.isTombstone(), wasRecovered,
         acceptedVersionTag);
   }
 
   @Override
-  public boolean initialImageInit(final LocalRegion region, final long lastModified,
+  public boolean initialImageInit(final InternalRegion region, final long lastModified,
       final Object newValue, final boolean create, final boolean wasRecovered,
       final boolean acceptedVersionTag) throws RegionClearedException {
 
@@ -772,7 +777,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
    */
   @Override
   @Released
-  public boolean destroy(LocalRegion region, EntryEventImpl event, boolean inTokenMode,
+  public boolean destroy(InternalRegion region, EntryEventImpl event, boolean inTokenMode,
       boolean cacheWrite, @Unretained Object expectedOldValue, boolean forceDestroy,
       boolean removeRecoveredEntry) throws CacheWriterException, EntryNotFoundException,
       TimeoutException, RegionClearedException {
@@ -794,7 +799,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
     ReferenceCountHelper.skipRefCountTracking();
     @Retained
     @Released
-    Object curValue = _getValueRetain(region, true);
+    Object curValue = getValueRetain(region, true);
     ReferenceCountHelper.unskipRefCountTracking();
     boolean proceed;
     try {
@@ -927,13 +932,13 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   public static boolean checkExpectedOldValue(@Unretained Object expectedOldValue,
-      @Unretained Object actualValue, LocalRegion lr) {
+      @Unretained Object actualValue, InternalRegion region) {
 
     if (Token.isInvalid(expectedOldValue)) {
       return actualValue == null || Token.isInvalid(actualValue);
     } else {
       boolean isCompressedOffHeap =
-          lr.getAttributes().getOffHeap() && lr.getAttributes().getCompressor() != null;
+          region.getAttributes().getOffHeap() && region.getAttributes().getCompressor() != null;
       return checkEquals(expectedOldValue, actualValue, isCompressedOffHeap);
     }
   }
@@ -1404,7 +1409,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
 
   @Override
   @Unretained
-  public Object _getValue() {
+  public Object getValue() {
     return getValueField();
   }
 
@@ -1457,7 +1462,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   @Override
-  public synchronized void decRefCount(NewLRUClockHand lruList, LocalRegion lr) {
+  public synchronized void decRefCount(NewLRUClockHand lruList, InternalRegion region) {
     if (TXManagerImpl.decRefCount(this)) {
       if (isInUseByTransaction()) {
         setInUseByTransaction(false);
@@ -1465,8 +1470,8 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
           // No more transactions, place in lru list
           lruList.appendEntry((LRUClockNode) this);
         }
-        if (lr != null && lr.isEntryExpiryPossible()) {
-          lr.addExpiryTaskIfAbsent(this);
+        if (region != null && region.isEntryExpiryPossible()) {
+          region.addExpiryTaskIfAbsent(this);
         }
       }
     }
@@ -1514,7 +1519,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   @Override
   @Retained
   public Object getTransformedValue() {
-    return _getValueRetain(null, false);
+    return getValueRetain(null, false);
   }
 
   @Override
@@ -1567,7 +1572,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   protected StringBuilder appendFieldsToString(final StringBuilder sb) {
     // OFFHEAP _getValue ok: the current toString on ObjectChunk is safe to use without incing
     // refcount.
-    sb.append("key=").append(getKey()).append("; rawValue=").append(_getValue());
+    sb.append("key=").append(getKey()).append("; rawValue=").append(getValue());
     VersionStamp stamp = getVersionStamp();
     if (stamp != null) {
       sb.append("; version=").append(stamp.asVersionTag()).append(";member=")
@@ -1581,8 +1586,8 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
    * versioning. It also sets the entry's version stamp to the tag's values.
    */
   @Override
-  public VersionTag generateVersionTag(VersionSource member, boolean withDelta, LocalRegion region,
-      EntryEventImpl event) {
+  public VersionTag generateVersionTag(VersionSource member, boolean withDelta,
+      InternalRegion region, EntryEventImpl event) {
     VersionStamp stamp = this.getVersionStamp();
     if (stamp != null && region.getServerProxy() == null) {
       // clients do not generate versions
@@ -1710,7 +1715,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
       final InternalDistributedMember originator =
           (InternalDistributedMember) event.getDistributedMember();
       final VersionSource dmId = event.getRegion().getVersionMember();
-      LocalRegion r = event.getLocalRegion();
+      InternalRegion r = event.getLocalRegion();
       boolean eventHasDelta = event.getDeltaBytes() != null && event.getRawNewValue() == null;
 
       VersionStamp stamp = getVersionStamp();
@@ -1791,7 +1796,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
     }
   }
 
-  protected void basicProcessVersionTag(LocalRegion region, VersionTag tag,
+  protected void basicProcessVersionTag(InternalRegion region, VersionTag tag,
       boolean isTombstoneFromGII, boolean deltaCheck, VersionSource dmId,
       InternalDistributedMember sender, boolean checkForConflict) {
 
@@ -1849,7 +1854,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
     }
   }
 
-  private void applyVersionTag(LocalRegion region, VersionStamp stamp, VersionTag tag,
+  private void applyVersionTag(InternalRegion region, VersionStamp stamp, VersionTag tag,
       InternalDistributedMember sender) {
     VersionSource mbr = tag.getMemberID();
     if (mbr == null) {
@@ -1869,7 +1874,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   /** perform conflict checking for a stamp/tag */
-  private boolean checkForConflict(LocalRegion region, VersionStamp stamp, VersionTag tag,
+  private boolean checkForConflict(InternalRegion region, VersionStamp stamp, VersionTag tag,
       boolean isTombstoneFromGII, boolean deltaCheck, VersionSource dmId,
       InternalDistributedMember sender, StringBuilder verbose) {
 
@@ -1977,12 +1982,12 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
     return apply;
   }
 
-  private boolean isExpiredTombstone(LocalRegion region, long timestamp, boolean isTombstone) {
+  private boolean isExpiredTombstone(InternalRegion region, long timestamp, boolean isTombstone) {
     return isTombstone
         && timestamp + TombstoneService.REPLICATE_TOMBSTONE_TIMEOUT <= region.cacheTimeMillis();
   }
 
-  private boolean overwritingOldTombstone(LocalRegion region, VersionStamp stamp, VersionTag tag,
+  private boolean overwritingOldTombstone(InternalRegion region, VersionStamp stamp, VersionTag tag,
       StringBuilder verbose) {
     // Tombstone GC does not use locking to stop operations when old tombstones
     // are being removed. Because of this we might get an operation that was applied
@@ -2002,7 +2007,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
     }
   }
 
-  protected void persistConflictingTag(LocalRegion region, VersionTag tag) {
+  protected void persistConflictingTag(InternalRegion region, VersionTag tag) {
     // only persist region needs to persist conflict tag
   }
 
@@ -2011,7 +2016,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
    * stamp's member id and ensure that the version is only incremented by 1. Otherwise the delta is
    * being applied to a value that does not match the source of the delta.
    */
-  private void checkForDeltaConflict(LocalRegion region, long stampVersion, long tagVersion,
+  private void checkForDeltaConflict(InternalRegion region, long stampVersion, long tagVersion,
       VersionStamp stamp, VersionTag tag, VersionSource dmId, InternalDistributedMember sender,
       StringBuilder verbose) {
 
@@ -2045,7 +2050,7 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
   }
 
   private boolean processGatewayTag(EntryEvent cacheEvent) {
-    // Gateway tags are installed in the server-side LocalRegion cache
+    // Gateway tags are installed in the server-side InternalRegion cache
     // modification methods. They do not have version numbers or distributed
     // member IDs. Instead they only have timestamps and distributed system IDs.
 
@@ -2212,11 +2217,11 @@ public abstract class AbstractRegionEntry implements RegionEntry, HashEntry<Obje
    */
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(RegionEntryContext context, boolean decompress) {
     if (decompress) {
-      return decompress(context, _getValue());
+      return decompress(context, getValue());
     } else {
-      return _getValue();
+      return getValue();
     }
   }
 
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/DiskEntry.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/DiskEntry.java
index 210d76b..6de7f93 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/DiskEntry.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/DiskEntry.java
@@ -38,7 +38,7 @@ import org.apache.geode.internal.cache.DistributedRegion;
 import org.apache.geode.internal.cache.EntryBits;
 import org.apache.geode.internal.cache.EntryEventImpl;
 import org.apache.geode.internal.cache.InitialImageOperation;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionClearedException;
 import org.apache.geode.internal.cache.RegionEntry;
@@ -48,6 +48,7 @@ import org.apache.geode.internal.cache.Token;
 import org.apache.geode.internal.cache.lru.EnableLRU;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.LRUEntry;
+import org.apache.geode.internal.cache.partitioned.Bucket;
 import org.apache.geode.internal.cache.persistence.BytesAndBits;
 import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.persistence.DiskRegionView;
@@ -228,7 +229,7 @@ public interface DiskEntry extends RegionEntry {
         synchronized (syncObj) {
           if (did != null && did.isPendingAsync()) {
             @Retained
-            Object v = entry._getValueRetain(context, true);
+            Object v = entry.getValueRetain(context, true);
 
             if (Token.isRemovedFromDisk(v)) {
               v = null;
@@ -317,7 +318,7 @@ public interface DiskEntry extends RegionEntry {
 
           // OFFHEAP copied to heap entry;
           // TODO: allow entry to refer to offheap since it will be copied to network.
-          v = de._getValueRetain(context, true);
+          v = de.getValueRetain(context, true);
 
           ReferenceCountHelper.setReferenceCountOwner(null);
           if (v == null) {
@@ -439,12 +440,13 @@ public interface DiskEntry extends RegionEntry {
     /**
      * Used to initialize a new disk entry
      */
-    public static void initialize(DiskEntry entry, DiskRecoveryStore r, Object newValue) {
+    public static void initialize(DiskEntry entry, DiskRecoveryStore diskRecoveryStore,
+        Object newValue) {
       DiskRegionView drv = null;
-      if (r instanceof LocalRegion) {
-        drv = ((LocalRegion) r).getDiskRegion();
-      } else if (r instanceof DiskRegionView) {
-        drv = (DiskRegionView) r;
+      if (diskRecoveryStore instanceof InternalRegion) {
+        drv = ((InternalRegion) diskRecoveryStore).getDiskRegion();
+      } else if (diskRecoveryStore instanceof DiskRegionView) {
+        drv = (DiskRegionView) diskRecoveryStore;
       }
       if (drv == null) {
         throw new IllegalArgumentException(
@@ -461,12 +463,12 @@ public interface DiskEntry extends RegionEntry {
         did.setUserBits(re.getUserBits());
         did.setValueLength(re.getValueLength());
         if (!re.getValueRecovered()) {
-          updateStats(drv, r, 0/* InVM */, 1/* OnDisk */, did.getValueLength());
+          updateStats(drv, diskRecoveryStore, 0, 1, did.getValueLength());
         } else {
-          entry.setValueWithContext(drv,
-              entry.prepareValueForCache((RegionEntryContext) r, re.getValue(), false));
+          entry.setValueWithContext(drv, entry
+              .prepareValueForCache((RegionEntryContext) diskRecoveryStore, re.getValue(), false));
           if (!Token.isInvalidOrRemoved(re.getValue())) {
-            updateStats(drv, r, 1/* InVM */, 0/* OnDisk */, 0);
+            updateStats(drv, diskRecoveryStore, 1, 0, 0);
           }
         }
       } else {
@@ -475,7 +477,7 @@ public interface DiskEntry extends RegionEntry {
           did.setKeyId(DiskRegion.INVALID_ID);
         }
         if (newValue != null && !Token.isInvalidOrRemoved(newValue)) {
-          updateStats(drv, r, 1/* InVM */, 0/* OnDisk */, 0);
+          updateStats(drv, diskRecoveryStore, 1, 0, 0);
         }
       }
     }
@@ -774,7 +776,7 @@ public interface DiskEntry extends RegionEntry {
       }
     }
 
-    public static ValueWrapper createValueWrapperFromEntry(DiskEntry entry, LocalRegion region,
+    public static ValueWrapper createValueWrapperFromEntry(DiskEntry entry, InternalRegion region,
         EntryEventImpl event) {
       if (event != null) {
         // For off-heap it should be faster to pass a reference to the
@@ -797,7 +799,7 @@ public interface DiskEntry extends RegionEntry {
         }
       }
       @Retained
-      Object value = entry._getValueRetain(region, true);
+      Object value = entry.getValueRetain(region, true);
       try {
         return createValueWrapper(value, event);
       } finally {
@@ -805,7 +807,7 @@ public interface DiskEntry extends RegionEntry {
       }
     }
 
-    private static void writeToDisk(DiskEntry entry, LocalRegion region, boolean async)
+    private static void writeToDisk(DiskEntry entry, InternalRegion region, boolean async)
         throws RegionClearedException {
       writeToDisk(entry, region, async, null);
     }
@@ -815,12 +817,12 @@ public interface DiskEntry extends RegionEntry {
      * 
      * @see DiskRegion#put
      */
-    private static void writeToDisk(DiskEntry entry, LocalRegion region, boolean async,
+    private static void writeToDisk(DiskEntry entry, InternalRegion region, boolean async,
         EntryEventImpl event) throws RegionClearedException {
       writeBytesToDisk(entry, region, async, createValueWrapperFromEntry(entry, region, event));
     }
 
-    private static void writeBytesToDisk(DiskEntry entry, LocalRegion region, boolean async,
+    private static void writeBytesToDisk(DiskEntry entry, InternalRegion region, boolean async,
         ValueWrapper vw) throws RegionClearedException {
       // @todo does the following unmark need to be called when an async
       // write is scheduled or is it ok for doAsyncFlush to do it?
@@ -828,7 +830,7 @@ public interface DiskEntry extends RegionEntry {
       region.getDiskRegion().put(entry, region, vw, async);
     }
 
-    public static void update(DiskEntry entry, LocalRegion region, Object newValue)
+    public static void update(DiskEntry entry, InternalRegion region, Object newValue)
         throws RegionClearedException {
       update(entry, region, newValue, null);
     }
@@ -837,7 +839,7 @@ public interface DiskEntry extends RegionEntry {
      * Updates the value of the disk entry with a new value. This allows us to free up disk space in
      * the non-backup case.
      */
-    public static void update(DiskEntry entry, LocalRegion region, Object newValue,
+    public static void update(DiskEntry entry, InternalRegion region, Object newValue,
         EntryEventImpl event) throws RegionClearedException {
       if (newValue == null) {
         throw new NullPointerException(
@@ -869,8 +871,8 @@ public interface DiskEntry extends RegionEntry {
       }
     }
 
-    private static AsyncDiskEntry basicUpdate(DiskEntry entry, LocalRegion region, Object newValue,
-        EntryEventImpl event) throws RegionClearedException {
+    private static AsyncDiskEntry basicUpdate(DiskEntry entry, InternalRegion region,
+        Object newValue, EntryEventImpl event) throws RegionClearedException {
       AsyncDiskEntry result = null;
       DiskRegion dr = region.getDiskRegion();
       DiskId did = entry.getDiskId();
@@ -999,7 +1001,7 @@ public interface DiskEntry extends RegionEntry {
       return result;
     }
 
-    public static Object getValueInVMOrDiskWithoutFaultIn(DiskEntry entry, LocalRegion region) {
+    public static Object getValueInVMOrDiskWithoutFaultIn(DiskEntry entry, InternalRegion region) {
       Object result =
           OffHeapHelper.copyAndReleaseIfNeeded(getValueOffHeapOrDiskWithoutFaultIn(entry, region));
       if (result instanceof CachedDeserializable) {
@@ -1009,13 +1011,14 @@ public interface DiskEntry extends RegionEntry {
     }
 
     @Retained
-    public static Object getValueOffHeapOrDiskWithoutFaultIn(DiskEntry entry, LocalRegion region) {
+    public static Object getValueOffHeapOrDiskWithoutFaultIn(DiskEntry entry,
+        InternalRegion region) {
       @Retained
-      Object v = entry._getValueRetain(region, true);
+      Object v = entry.getValueRetain(region, true);
 
       if (v == null || Token.isRemovedFromDisk(v) && !region.isIndexCreationThread()) {
         synchronized (entry) {
-          v = entry._getValueRetain(region, true);
+          v = entry.getValueRetain(region, true);
 
           if (v == null) {
             v = Helper.getOffHeapValueOnDiskOrBuffer(entry, region.getDiskRegion(), region);
@@ -1029,12 +1032,12 @@ public interface DiskEntry extends RegionEntry {
       return v;
     }
 
-    public static Object faultInValue(DiskEntry entry, LocalRegion region) {
+    public static Object faultInValue(DiskEntry entry, InternalRegion region) {
       return faultInValue(entry, region, false);
     }
 
     @Retained
-    public static Object faultInValueRetain(DiskEntry entry, LocalRegion region) {
+    public static Object faultInValueRetain(DiskEntry entry, InternalRegion region) {
       return faultInValue(entry, region, true);
     }
 
@@ -1042,10 +1045,11 @@ public interface DiskEntry extends RegionEntry {
      * @param retainResult if true then the result may be a retained off-heap reference
      */
     @Retained
-    private static Object faultInValue(DiskEntry entry, LocalRegion region, boolean retainResult) {
+    private static Object faultInValue(DiskEntry entry, InternalRegion region,
+        boolean retainResult) {
       DiskRegion dr = region.getDiskRegion();
       @Retained
-      Object v = entry._getValueRetain(region, true);
+      Object v = entry.getValueRetain(region, true);
 
       boolean lruFaultedIn = false;
       boolean done = false;
@@ -1066,20 +1070,20 @@ public interface DiskEntry extends RegionEntry {
                   did.setPendingAsync(false);
                 }
               }
-              lruEntryFaultIn((LRUEntry) entry, region);
+              lruEntryFaultIn((LRUEntry) entry, (DiskRecoveryStore) region);
               lruFaultedIn = true;
             }
           }
         }
         if (!done && (v == null || Token.isRemovedFromDisk(v) && !region.isIndexCreationThread())) {
           synchronized (entry) {
-            v = entry._getValueRetain(region, true);
+            v = entry.getValueRetain(region, true);
 
             if (v == null) {
-              v = readValueFromDisk(entry, region);
+              v = readValueFromDisk(entry, (DiskRecoveryStore) region);
               if (entry instanceof LRUEntry) {
                 if (v != null && !Token.isInvalid(v)) {
-                  lruEntryFaultIn((LRUEntry) entry, region);
+                  lruEntryFaultIn((LRUEntry) entry, (DiskRecoveryStore) region);
 
                   lruFaultedIn = true;
                 }
@@ -1100,7 +1104,7 @@ public interface DiskEntry extends RegionEntry {
         ((RegionEntry) entry).setRecentlyUsed();
       }
       if (lruFaultedIn) {
-        lruUpdateCallback(region);
+        lruUpdateCallback((DiskRecoveryStore) region);
       }
       return v; // OFFHEAP: the value ends up being returned by RegionEntry.getValue
     }
@@ -1294,7 +1298,7 @@ public interface DiskEntry extends RegionEntry {
       // Note: we used to call owner.incNumOverflowBytesOnDisk()
       // if owner was a DiskRegionView.
       // But since we also call drv.incNumOverflowBytesOnDisk()
-      // and since drv is == owner when owner is not a LocalRegion
+      // and since drv is == owner when owner is not a InternalRegion
       // (see PlaceHolderDiskRegion.getDiskRegionView())
       // this resulted in incNumOverflowBytesOnDisk being called twice.
     }
@@ -1307,14 +1311,14 @@ public interface DiskEntry extends RegionEntry {
      * <p>
      * Caller must synchronize on entry and it is assumed the entry is evicted
      */
-    public static int overflowToDisk(DiskEntry entry, LocalRegion region, EnableLRU ccHelper)
+    public static int overflowToDisk(DiskEntry entry, InternalRegion region, EnableLRU ccHelper)
         throws RegionClearedException {
       DiskRegion dr = region.getDiskRegion();
-      final int oldSize = region.calculateRegionEntryValueSize(entry);
+      final int oldSize = ((DiskRecoveryStore) region).calculateRegionEntryValueSize(entry);
       // Get diskID . If it is null, it implies it is overflow only mode.
       DiskId did = entry.getDiskId();
       if (did == null) {
-        ((LRUEntry) entry).setDelayedDiskId(region);
+        ((LRUEntry) entry).setDelayedDiskId((DiskRecoveryStore) region);
         did = entry.getDiskId();
       }
 
@@ -1376,12 +1380,12 @@ public interface DiskEntry extends RegionEntry {
       dr.scheduleAsyncWrite(ade);
     }
 
-
-    public static void handleFullAsyncQueue(DiskEntry entry, LocalRegion region, VersionTag tag) {
+    public static void handleFullAsyncQueue(DiskEntry entry, InternalRegion region,
+        VersionTag tag) {
       writeEntryToDisk(entry, region, tag, true);
     }
 
-    public static void doAsyncFlush(VersionTag tag, LocalRegion region) {
+    public static void doAsyncFlush(VersionTag tag, InternalRegion region) {
       if (region.isThisRegionBeingClosedOrDestroyed())
         return;
       DiskRegion dr = region.getDiskRegion();
@@ -1402,7 +1406,7 @@ public interface DiskEntry extends RegionEntry {
      * 
      * @since GemFire prPersistSprint1
      */
-    public static void doAsyncFlush(DiskEntry entry, LocalRegion region, VersionTag tag) {
+    public static void doAsyncFlush(DiskEntry entry, InternalRegion region, VersionTag tag) {
       writeEntryToDisk(entry, region, tag, false);
     }
 
@@ -1413,7 +1417,7 @@ public interface DiskEntry extends RegionEntry {
      * @param asyncQueueWasFull true if caller wanted to put this entry in the queue but could not
      *        do so because it was full
      */
-    private static void writeEntryToDisk(DiskEntry entry, LocalRegion region, VersionTag tag,
+    private static void writeEntryToDisk(DiskEntry entry, InternalRegion region, VersionTag tag,
         boolean asyncQueueWasFull) {
       if (region.isThisRegionBeingClosedOrDestroyed())
         return;
@@ -1436,7 +1440,8 @@ public interface DiskEntry extends RegionEntry {
               if (did.isPendingAsync()) {
                 did.setPendingAsync(false);
                 final Token entryVal = entry.getValueAsToken();
-                final int entryValSize = region.calculateRegionEntryValueSize(entry);
+                final int entryValSize =
+                    ((DiskRecoveryStore) region).calculateRegionEntryValueSize(entry);
                 try {
                   if (Token.isRemovedFromDisk(entryVal)) {
                     if (region.isThisRegionBeingClosedOrDestroyed())
@@ -1506,7 +1511,7 @@ public interface DiskEntry extends RegionEntry {
      * @throws RegionClearedException If the operation is aborted due to a clear
      * @see DiskRegion#remove
      */
-    public static void removeFromDisk(DiskEntry entry, LocalRegion region, boolean isClear)
+    public static void removeFromDisk(DiskEntry entry, InternalRegion region, boolean isClear)
         throws RegionClearedException {
       DiskRegion dr = region.getDiskRegion();
       DiskId did = entry.getDiskId();
@@ -1533,7 +1538,7 @@ public interface DiskEntry extends RegionEntry {
       }
     }
 
-    private static AsyncDiskEntry basicRemoveFromDisk(DiskEntry entry, LocalRegion region,
+    private static AsyncDiskEntry basicRemoveFromDisk(DiskEntry entry, InternalRegion region,
         boolean isClear) throws RegionClearedException {
       final DiskRegion dr = region.getDiskRegion();
       final DiskId did = entry.getDiskId();
@@ -1583,7 +1588,7 @@ public interface DiskEntry extends RegionEntry {
       return result;
     }
 
-    public static void updateVersionOnly(DiskEntry entry, LocalRegion region, VersionTag tag) {
+    public static void updateVersionOnly(DiskEntry entry, InternalRegion region, VersionTag tag) {
       DiskRegion dr = region.getDiskRegion();
       if (!dr.isBackup()) {
         return;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/LeafRegionEntry.cpp b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/LeafRegionEntry.cpp
index b01773a..158b56d 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/LeafRegionEntry.cpp
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/LeafRegionEntry.cpp
@@ -38,24 +38,24 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 #if defined(VERSIONED)
 import org.apache.geode.cache.EntryEvent;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 #endif
 import org.apache.geode.internal.cache.RegionEntryContext;
 #if defined(DISK) || defined(LRU)
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 #endif
 #ifdef DISK
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 #endif
 #ifdef STATS
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 #endif
 #ifdef LRU
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 #endif
@@ -74,32 +74,141 @@ import org.apache.geode.internal.offheap.annotations.Unretained;
 #endif
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK
+ * lru: LRU
+ * stats: STATS
+ * versioned: VERSIONED
+ * offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT
+ * key int: KEY_INT
+ * key long: KEY_LONG
+ * key uuid: KEY_UUID
+ * key string1: KEY_STRING1
+ * key string2: KEY_STRING2
+ */
 
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class LEAF_CLASS extends PARENT_CLASS {
-  public LEAF_CLASS  (RegionEntryContext context, KEY_TYPE key, 
+
+  // --------------------------------------- common fields ----------------------------------------
+
+  private static final AtomicLongFieldUpdater<LEAF_CLASS> LAST_MODIFIED_UPDATER
+    = AtomicLongFieldUpdater.newUpdater(LEAF_CLASS.class, "lastModified");
+
+  protected int hash;
+
+  private HashEntry<Object, Object> nextEntry;
+
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+
+#ifdef OFFHEAP
+#else
+  private volatile Object value;
+#endif
+#ifdef OFFHEAP
+  // --------------------------------------- offheap fields ---------------------------------------
+
+  /**
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
+   */
+  @SuppressWarnings("unused")
+  @Retained @Released private volatile long offHeapAddress;
+  /**
+   * I needed to add this because I wanted clear to call setValue which normally can only be called
+   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
+   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
+   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
+   */
+  private static final AtomicLongFieldUpdater<LEAF_CLASS> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(LEAF_CLASS.class, "offHeapAddress");
+#endif
+#ifdef DISK
+
+  // ---------------------------------------- disk fields -----------------------------------------
+
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+#endif
+#ifdef STATS
+
+  // --------------------------------------- stats fields -----------------------------------------
+
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+
+  private static final AtomicIntegerFieldUpdater<LEAF_CLASS> HIT_COUNT_UPDATER
+    = AtomicIntegerFieldUpdater.newUpdater(LEAF_CLASS.class, "hitCount");
+
+  private static final AtomicIntegerFieldUpdater<LEAF_CLASS> MISS_COUNT_UPDATER
+    = AtomicIntegerFieldUpdater.newUpdater(LEAF_CLASS.class, "missCount");
+#endif
+#ifdef VERSIONED
+
+  // ------------------------------------- versioned fields ---------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+
+  private VersionSource memberId;
+  private short entryVersionLowBytes;
+  private short regionVersionHighBytes;
+  private int regionVersionLowBytes;
+  private byte entryVersionHighByte;
+  private byte distributedSystemId;
+#endif
+
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+
+#ifdef KEY_OBJECT
+  private final Object key;
+#elif defined(KEY_INT)
+  private final int key;
+#elif defined(KEY_LONG)
+  private final long key;
+#elif defined(KEY_LONG)
+  private final long key;
+#elif defined(KEY_UUID)
+  private final long keyMostSigBits;
+  private final long keyLeastSigBits;
+#elif defined(KEY_STRING1)
+  private final long bits1;
+#elif defined(KEY_STRING2)
+  /**
+   * strlen is encoded in lowest 6 bits (max strlen is 63)<br>
+   * character encoding info is in bits 7 and 8<br>
+   * The other bits are used to encoded character data.
+   */
+  private final long bits1;
+
+  /**
+   * bits2 encodes character data
+   */
+  private final long bits2;
+#endif
+
+  public LEAF_CLASS (final RegionEntryContext context, final KEY_TYPE key,
 #ifdef OFFHEAP
       @Retained
 #endif
-      Object value
+      final Object value
 #if defined(KEY_STRING1) || defined(KEY_STRING2)
-      , boolean byteEncode
+      , final boolean byteEncode
 #endif
       ) {
     super(context, 
@@ -124,80 +233,60 @@ public class LEAF_CLASS extends PARENT_CLASS {
     this.keyLeastSigBits = key.getLeastSignificantBits();
 #elif defined(KEY_STRING1)
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
+    long tempBits1 = 0L;
     if (byteEncode) {
-      for (int i=key.length()-1; i >= 0; i--) {
-        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to keep findbugs happy.
-        tmpBits1 |= (byte)key.charAt(i) & 0xff;
-        tmpBits1 <<= 8;
+      for (int i = key.length() - 1; i >= 0; i--) {
+        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
+        // keep findbugs happy.
+        tempBits1 |= (byte) key.charAt(i) & 0xff;
+        tempBits1 <<= 8;
       }
-      tmpBits1 |= 1<<6;
+      tempBits1 |= 1<<6;
     } else {
-      for (int i=key.length()-1; i >= 0; i--) {
-        tmpBits1 |= key.charAt(i);
-        tmpBits1 <<= 16;
+      for (int i = key.length() - 1; i >= 0; i--) {
+        tempBits1 |= key.charAt(i);
+        tempBits1 <<= 16;
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
 #elif defined(KEY_STRING2)
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    long tmpBits2 = 0L;
+    long tempBits1 = 0L;
+    long tempBits2 = 0L;
     if (byteEncode) {
-      for (int i=key.length()-1; i >= 0; i--) {
-        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to keep findbugs happy.
+      for (int i = key.length() - 1; i >= 0; i--) {
+        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
+        // keep findbugs happy.
         if (i < 7) {
-          tmpBits1 |= (byte)key.charAt(i) & 0xff;
-          tmpBits1 <<= 8;
+          tempBits1 |= (byte)key.charAt(i) & 0xff;
+          tempBits1 <<= 8;
         } else {
-          tmpBits2 <<= 8;
-          tmpBits2 |= (byte)key.charAt(i) & 0xff;
+          tempBits2 <<= 8;
+          tempBits2 |= (byte)key.charAt(i) & 0xff;
         }
       }
-      tmpBits1 |= 1<<6;
+      tempBits1 |= 1<<6;
     } else {
-      for (int i=key.length()-1; i >= 0; i--) {
+      for (int i = key.length() - 1; i >= 0; i--) {
         if (i < 3) {
-          tmpBits1 |= key.charAt(i);
-          tmpBits1 <<= 16;
+          tempBits1 |= key.charAt(i);
+          tempBits1 <<= 16;
         } else {
-          tmpBits2 <<= 16;
-          tmpBits2 |= key.charAt(i);
+          tempBits2 <<= 16;
+          tempBits2 |= key.charAt(i);
         }
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-    this.bits2 = tmpBits2;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+    this.bits2 = tempBits2;
 #endif
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<LEAF_CLASS> lastModifiedUpdater
-    = AtomicLongFieldUpdater.newUpdater(LEAF_CLASS.class, "lastModified");
+
 #ifdef OFFHEAP
-  /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
-   */
-  @SuppressWarnings("unused")
-  @Retained @Released private volatile long ohAddress;
-  /**
-   * I needed to add this because I wanted clear to call setValue which normally can only be called while the re is synced.
-   * But if I sync in that code it causes a lock ordering deadlock with the disk regions because they also get a rw lock in clear.
-   * Some hardware platforms do not support CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync
-   * on the re and we will once again be deadlocked.
-   * I don't know if we support any of the hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks
-   * on disk regions.
-   */
-  private final static AtomicLongFieldUpdater<LEAF_CLASS> ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(LEAF_CLASS.class, "ohAddress");
-  
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -209,31 +298,33 @@ public class LEAF_CLASS extends PARENT_CLASS {
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+
   @Override
 #ifdef OFFHEAP
   @Unretained
-  protected void setValueField(@Unretained Object v) {
+  protected void setValueField(@Unretained final Object value) {
 #else
-  protected void setValueField(Object v) {
+  protected void setValueField(final Object value) {
 #endif
-    OffHeapRegionEntryHelper.setValue(this, v);
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
+
   @Override
 #ifdef OFFHEAP
   @Retained
 #endif
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
   
   @Override
@@ -246,154 +337,169 @@ public class LEAF_CLASS extends PARENT_CLASS {
   
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
-#else    
-  private volatile Object value;
+#else
   @Override
   protected Object getValueField() {
     return this.value;
   }
+
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 #endif
+
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
-  protected void setEntryHash(int v) {
-    this.hash = v;
+
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 #ifdef DISK
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  
-  // disk code
+
 #ifdef LRU
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion)drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
+
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
-    int newSize = capacityController.entrySize( getKeyForSizing(), null);
+    int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
     int delta = newSize - oldSize;
     return delta;
   }
 #else
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
+
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 #endif
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore)context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    //get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;//= new DiskId();
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
+
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry)old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 #endif
   
 #ifdef LRU
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  
-  // lru code
+
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
 #ifdef DISK
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
 #else
     // nothing needed for LRUs with no disk
 #endif
   }
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue());  // OFHEAP: _getValue ok w/o incing refcount because we are synced and only getting the size
+
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
   
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
-  public synchronized int updateEntrySize(EnableLRU capacityController,
-                                                Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
-    int newSize = capacityController.entrySize( getKeyForSizing(), value);
+    int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
     int delta = newSize - oldSize;
     return delta;
   }
+
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
+
   @Override
   public void setRecentlyUsed() {
     setBits(RECENTLY_USED);
   }
+
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
+
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
+
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
+
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
@@ -401,24 +507,35 @@ public class LEAF_CLASS extends PARENT_CLASS {
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
 
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
-  public void setNextLRUNode( LRUClockNode next ) {
-    this.nextLRU = next;
+
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
+
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
-  public void setPrevLRUNode( LRUClockNode prev ) {
-    this.prevLRU = prev;
+
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
+
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
+
+  @Override
   public int getEntrySize() {
     return this.size;
   }
-  protected void setEntrySize(int size) {
+
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -437,71 +554,70 @@ public class LEAF_CLASS extends PARENT_CLASS {
 #endif
 
 #ifdef STATS
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  
-  // stats code
+
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
     }
   }
+
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { 
       setLastAccessed(lastAccessed);
     }
   }
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  
-  private static final AtomicIntegerFieldUpdater<LEAF_CLASS> hitCountUpdater 
-    = AtomicIntegerFieldUpdater.newUpdater(LEAF_CLASS.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<LEAF_CLASS> missCountUpdater 
-    = AtomicIntegerFieldUpdater.newUpdater(LEAF_CLASS.class, "missCount");
-  
+
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
+
   @Override
   public long getHitCount() throws InternalStatisticsDisabledException {
     return this.hitCount & 0xFFFFFFFFL;
   }
+
   @Override
   public long getMissCount() throws InternalStatisticsDisabledException {
     return this.missCount & 0xFFFFFFFFL;
   }
+
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
+
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
+
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this,0);
-    missCountUpdater.set(this,0);
+    HIT_COUNT_UPDATER.set(this,0);
+    MISS_COUNT_UPDATER.set(this,0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
+
   @Override
   public boolean hasStats() {
     return true;
@@ -509,63 +625,66 @@ public class LEAF_CLASS extends PARENT_CLASS {
 #endif
   
 #ifdef VERSIONED
+  // -------------------------------------- versioned code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  
-  // versioned code
-  private VersionSource memberID;
-  private short entryVersionLowBytes;
-  private short regionVersionHighBytes;
-  private int regionVersionLowBytes;
-  private byte entryVersionHighByte;
-  private byte distributedSystemId;
 
+  @Override
   public int getEntryVersion() {
     return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF);
   }
   
+  @Override
   public long getRegionVersion() {
     return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL);  
   }
-  
-  
+
+  @Override
   public long getVersionTimeStamp() {
     return getLastModified();
   }
   
-  public void setVersionTimeStamp(long time) {
-    setLastModified(time);
+  @Override
+  public void setVersionTimeStamp(final long timeStamp) {
+    setLastModified(timeStamp);
   }
 
+  @Override
   public VersionSource getMemberID() {
-    return this.memberID;
+    return this.memberId;
   }
+
+  @Override
   public int getDistributedSystemId() {
     return this.distributedSystemId;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
-  public void setVersions(VersionTag tag) {
-    this.memberID = tag.getMemberID();
-    int eVersion = tag.getEntryVersion();
-    this.entryVersionLowBytes = (short)(eVersion & 0xffff);
-    this.entryVersionHighByte = (byte)((eVersion & 0xff0000) >> 16);
-    this.regionVersionHighBytes = tag.getRegionVersionHighBytes();
-    this.regionVersionLowBytes = tag.getRegionVersionLowBytes();
-    if (!(tag.isGatewayTag()) && this.distributedSystemId == tag.getDistributedSystemId()) {
-      if (getVersionTimeStamp() <= tag.getVersionTimeStamp()) {
-        setVersionTimeStamp(tag.getVersionTimeStamp());
+  @Override
+  public void setVersions(final VersionTag versionTag) {
+    this.memberId = versionTag.getMemberID();
+    int eVersion = versionTag.getEntryVersion();
+    this.entryVersionLowBytes = (short) (eVersion & 0xffff);
+    this.entryVersionHighByte = (byte) ((eVersion & 0xff0000) >> 16);
+    this.regionVersionHighBytes = versionTag.getRegionVersionHighBytes();
+    this.regionVersionLowBytes = versionTag.getRegionVersionLowBytes();
+
+    if (!versionTag.isGatewayTag() && this.distributedSystemId == versionTag.getDistributedSystemId()) {
+      if (getVersionTimeStamp() <= versionTag.getVersionTimeStamp()) {
+        setVersionTimeStamp(versionTag.getVersionTimeStamp());
       } else {
-        tag.setVersionTimeStamp(getVersionTimeStamp());
+        versionTag.setVersionTimeStamp(getVersionTimeStamp());
       }
     } else {
-      setVersionTimeStamp(tag.getVersionTimeStamp());
+      setVersionTimeStamp(versionTag.getVersionTimeStamp());
     }
-    this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff);
+
+    this.distributedSystemId = (byte) (versionTag.getDistributedSystemId() & 0xff);
   }
 
-  public void setMemberID(VersionSource memberID) {
-    this.memberID = memberID; 
+  @Override
+  public void setMemberID(final VersionSource memberId) {
+    this.memberId = memberId;
   }
 
   @Override
@@ -575,8 +694,9 @@ public class LEAF_CLASS extends PARENT_CLASS {
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
+  @Override
   public VersionTag asVersionTag() {
-    VersionTag tag = VersionTag.create(memberID);
+    VersionTag tag = VersionTag.create(memberId);
     tag.setEntryVersion(getEntryVersion());
     tag.setRegionVersion(this.regionVersionHighBytes, this.regionVersionLowBytes);
     tag.setVersionTimeStamp(getVersionTimeStamp());
@@ -584,79 +704,79 @@ public class LEAF_CLASS extends PARENT_CLASS {
     return tag;
   }
 
-  public void processVersionTag(LocalRegion r, VersionTag tag,
-      boolean isTombstoneFromGII, boolean hasDelta,
-      VersionSource thisVM, InternalDistributedMember sender, boolean checkForConflicts) {
-    basicProcessVersionTag(r, tag, isTombstoneFromGII, hasDelta, thisVM, sender, checkForConflicts);
+  @Override
+  public void processVersionTag(final InternalRegion region, final VersionTag versionTag,
+      final boolean isTombstoneFromGII, final boolean hasDelta, final VersionSource versionSource,
+      final InternalDistributedMember sender, final boolean checkForConflicts) {
+    basicProcessVersionTag(region, versionTag, isTombstoneFromGII, hasDelta, versionSource, sender, checkForConflicts);
   }
 
   @Override
-  public void processVersionTag(EntryEvent cacheEvent) {
-    // this keeps Eclipse happy. without it the sender chain becomes confused
-    // while browsing this code
+  public void processVersionTag(final EntryEvent cacheEvent) {
+    // this keeps IDE happy. without it the sender chain becomes confused while browsing this code
     super.processVersionTag(cacheEvent);
   }
 
   /** get rvv internal high byte. Used by region entries for transferring to storage */
+  @Override
   public short getRegionVersionHighBytes() {
     return this.regionVersionHighBytes;
   }
   
   /** get rvv internal low bytes. Used by region entries for transferring to storage */
+  @Override
   public int getRegionVersionLowBytes() {
     return this.regionVersionLowBytes;
   }
 #endif
   
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  
-  // key code
+
 #ifdef KEY_OBJECT
-  private final Object key;
   @Override
   public Object getKey() {
     return this.key;
   }
 
 #elif defined(KEY_INT)
-  private final int key;
   @Override
   public Object getKey() {
     return this.key;
   }
+
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
   
 #elif defined(KEY_LONG)
-  private final long key;
   @Override
   public Object getKey() {
     return this.key;
   }
+
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
   
 #elif defined(KEY_UUID)
-  private final long keyMostSigBits;
-  private final long keyLeastSigBits;
   @Override
   public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
+
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof UUID) {
-      UUID uuid = (UUID) k;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof UUID) {
+      UUID uuid = (UUID) key;
       return uuid.getLeastSignificantBits() == this.keyLeastSigBits
           && uuid.getMostSignificantBits() == this.keyMostSigBits;
     }
@@ -664,60 +784,66 @@ public class LEAF_CLASS extends PARENT_CLASS {
   }
   
 #elif defined(KEY_STRING1)
-  private final long bits1;
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
+
   private int getEncoding() {
     // 0 means encoded as char
     // 1 means encoded as bytes that are all <= 0x7f;
     return (int) (this.bits1 >> 6) & 0x03;
   }
+
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+
     if (getEncoding() == 1) {
-      for (int i=0; i < keylen; i++) {
-        tmpBits1 >>= 8;
-      chars[i] = (char) (tmpBits1 & 0x00ff);
+      for (int i=0; i < keyLength; i++) {
+        tempBits1 >>= 8;
+      chars[i] = (char) (tempBits1 & 0x00ff);
       }
     } else {
-      for (int i=0; i < keylen; i++) {
-        tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+      for (int i=0; i < keyLength; i++) {
+        tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
       }
     }
+
     return new String(chars);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String)k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+
         if (getEncoding() == 1) {
-          for (int i=0; i < keylen; i++) {
-            tmpBits1 >>= 8;
-            char c = (char) (tmpBits1 & 0x00ff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 8;
+            char character = (char) (tempBits1 & 0x00ff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
+
         } else {
-          for (int i=0; i < keylen; i++) {
-            tmpBits1 >>= 16;
-            char c = (char) (tmpBits1 & 0x00FFff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 16;
+            char character = (char) (tempBits1 & 0x00FFff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         }
+
         return true;
       }
     }
@@ -725,44 +851,42 @@ public class LEAF_CLASS extends PARENT_CLASS {
   }
   
 #elif defined(KEY_STRING2)
-  // strlen is encoded in lowest 6 bits (max strlen is 63)
-  // character encoding info is in bits 7 and 8
-  // The other bits are used to encoded character data.
-  private final long bits1;
-  // bits2 encodes character data
-  private final long bits2;
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
+
   private int getEncoding() {
     // 0 means encoded as char
     // 1 means encoded as bytes that are all <= 0x7f;
     return (int) (this.bits1 >> 6) & 0x03;
   }
+
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
-    long tmpBits2 = this.bits2;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+    long tempBits2 = this.bits2;
+
     if (getEncoding() == 1) {
-      for (int i=0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 7) {
-          tmpBits1 >>= 8;
-          chars[i] = (char) (tmpBits1 & 0x00ff);
+          tempBits1 >>= 8;
+          chars[i] = (char) (tempBits1 & 0x00ff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00ff);
-          tmpBits2 >>= 8;
+          chars[i] = (char) (tempBits2 & 0x00ff);
+          tempBits2 >>= 8;
         }
       }
+
     } else {
-      for (int i=0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 3) {
-          tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+          tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00FFff);
-          tmpBits2 >>= 16;
+          chars[i] = (char) (tempBits2 & 0x00FFff);
+          tempBits2 >>= 16;
         }
       }
     }
@@ -772,47 +896,51 @@ public class LEAF_CLASS extends PARENT_CLASS {
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String)k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
-        long tmpBits2 = this.bits2;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String)key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+        long tempBits2 = this.bits2;
+
         if (getEncoding() == 1) {
-          for (int i=0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 7) {
-              tmpBits1 >>= 8;
-              c = (char) (tmpBits1 & 0x00ff);
+              tempBits1 >>= 8;
+              character = (char) (tempBits1 & 0x00ff);
             } else {
-              c = (char) (tmpBits2 & 0x00ff);
-              tmpBits2 >>= 8;
+              character = (char) (tempBits2 & 0x00ff);
+              tempBits2 >>= 8;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
+
         } else {
-          for (int i=0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 3) {
-              tmpBits1 >>= 16;
-              c = (char) (tmpBits1 & 0x00FFff);
+              tempBits1 >>= 16;
+              character = (char) (tempBits1 & 0x00FFff);
             } else {
-              c = (char) (tmpBits2 & 0x00FFff);
-              tmpBits2 >>= 16;
+              character = (char) (tempBits2 & 0x00FFff);
+              tempBits2 >>= 16;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         }
+
         return true;
       }
     }
     return false;
   }
 #endif
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
 }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapIntKey.java
index 14c3b90..7938420 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapIntKey.java
@@ -19,36 +19,59 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEntryHeap {
-  public VMStatsDiskLRURegionEntryHeapIntKey(RegionEntryContext context, int key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapIntKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapIntKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapIntKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapIntKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapIntKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapIntKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final int key;
+
+  public VMStatsDiskLRURegionEntryHeapIntKey(final RegionEntryContext context, final int key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -56,77 +79,65 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapIntKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapIntKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -135,48 +146,43 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -184,6 +190,7 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -193,48 +200,57 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -245,12 +261,12 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -258,28 +274,20 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapIntKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapIntKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapIntKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapIntKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -294,24 +302,24 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -321,19 +329,17 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final int key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapLongKey.java
index 2004c6a..a78012c 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapLongKey.java
@@ -19,36 +19,59 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEntryHeap {
-  public VMStatsDiskLRURegionEntryHeapLongKey(RegionEntryContext context, long key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapLongKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapLongKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapLongKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapLongKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapLongKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapLongKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long key;
+
+  public VMStatsDiskLRURegionEntryHeapLongKey(final RegionEntryContext context, final long key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -56,77 +79,65 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapLongKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapLongKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -135,48 +146,43 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -184,6 +190,7 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -193,48 +200,57 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -245,12 +261,12 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -258,28 +274,20 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapLongKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapLongKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapLongKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapLongKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -294,24 +302,24 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -321,19 +329,17 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapObjectKey.java
index bd40056..f30a3f4 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapObjectKey.java
@@ -19,37 +19,62 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegionEntryHeap {
-  public VMStatsDiskLRURegionEntryHeapObjectKey(RegionEntryContext context, Object key,
-      Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapObjectKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapObjectKey.class,
+          "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapObjectKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapObjectKey.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapObjectKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapObjectKey.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final Object key;
+
+  public VMStatsDiskLRURegionEntryHeapObjectKey(final RegionEntryContext context, final Object key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -57,78 +82,65 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapObjectKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapObjectKey.class,
-          "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -137,48 +149,43 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -186,6 +193,7 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -195,48 +203,57 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -247,12 +264,12 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
     return getKey();
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -260,30 +277,20 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapObjectKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapObjectKey.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapObjectKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapObjectKey.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -298,24 +305,24 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -325,10 +332,8 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final Object key;
-
   @Override
   public Object getKey() {
     return this.key;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapStringKey1.java
index 5e40c3a..20aadcc 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapStringKey1.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapStringKey1.java
@@ -19,133 +19,145 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegionEntryHeap {
-  public VMStatsDiskLRURegionEntryHeapStringKey1(RegionEntryContext context, String key,
-      Object value, boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey1> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey1.class,
+          "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey1> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey1.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey1> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey1.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long bits1;
+
+  public VMStatsDiskLRURegionEntryHeapStringKey1(final RegionEntryContext context, final String key,
+      final Object value, final boolean byteEncode) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
+    long tempBits1 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
-        tmpBits1 |= (byte) key.charAt(i) & 0xff;
-        tmpBits1 <<= 8;
+        tempBits1 |= (byte) key.charAt(i) & 0xff;
+        tempBits1 <<= 8;
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
-        tmpBits1 |= key.charAt(i);
-        tmpBits1 <<= 16;
+        tempBits1 |= key.charAt(i);
+        tempBits1 <<= 16;
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey1> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey1.class,
-          "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -154,48 +166,43 @@ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegio
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -203,6 +210,7 @@ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegio
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -212,48 +220,57 @@ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegio
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -264,12 +281,12 @@ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegio
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -277,30 +294,20 @@ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegio
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey1> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey1.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey1> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey1.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -315,24 +322,24 @@ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegio
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -342,10 +349,8 @@ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegio
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long bits1;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -358,18 +363,18 @@ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegio
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 8;
-        chars[i] = (char) (tmpBits1 & 0x00ff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 8;
+        chars[i] = (char) (tempBits1 & 0x00ff);
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
       }
     }
     return new String(chars);
@@ -377,25 +382,25 @@ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegio
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 8;
-            char c = (char) (tmpBits1 & 0x00ff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 8;
+            char character = (char) (tempBits1 & 0x00ff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 16;
-            char c = (char) (tmpBits1 & 0x00FFff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 16;
+            char character = (char) (tempBits1 & 0x00FFff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapStringKey2.java
index df6bd14..af52b1b 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapStringKey2.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapStringKey2.java
@@ -19,145 +19,166 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegionEntryHeap {
-  public VMStatsDiskLRURegionEntryHeapStringKey2(RegionEntryContext context, String key,
-      Object value, boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey2> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey2.class,
+          "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey2> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey2.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey2> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey2.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  /**
+   * strlen is encoded in lowest 6 bits (max strlen is 63)<br>
+   * character encoding info is in bits 7 and 8<br>
+   * The other bits are used to encoded character data.
+   */
+  private final long bits1;
+  /**
+   * bits2 encodes character data
+   */
+  private final long bits2;
+
+  public VMStatsDiskLRURegionEntryHeapStringKey2(final RegionEntryContext context, final String key,
+      final Object value, final boolean byteEncode) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    long tmpBits2 = 0L;
+    long tempBits1 = 0L;
+    long tempBits2 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
         if (i < 7) {
-          tmpBits1 |= (byte) key.charAt(i) & 0xff;
-          tmpBits1 <<= 8;
+          tempBits1 |= (byte) key.charAt(i) & 0xff;
+          tempBits1 <<= 8;
         } else {
-          tmpBits2 <<= 8;
-          tmpBits2 |= (byte) key.charAt(i) & 0xff;
+          tempBits2 <<= 8;
+          tempBits2 |= (byte) key.charAt(i) & 0xff;
         }
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
         if (i < 3) {
-          tmpBits1 |= key.charAt(i);
-          tmpBits1 <<= 16;
+          tempBits1 |= key.charAt(i);
+          tempBits1 <<= 16;
         } else {
-          tmpBits2 <<= 16;
-          tmpBits2 |= key.charAt(i);
+          tempBits2 <<= 16;
+          tempBits2 |= key.charAt(i);
         }
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-    this.bits2 = tmpBits2;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+    this.bits2 = tempBits2;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey2> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey2.class,
-          "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -166,48 +187,43 @@ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegio
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -215,6 +231,7 @@ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegio
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -224,48 +241,57 @@ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegio
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -276,12 +302,12 @@ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegio
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -289,30 +315,20 @@ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegio
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey2> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey2.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapStringKey2> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapStringKey2.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -327,24 +343,24 @@ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegio
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -354,15 +370,8 @@ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegio
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  // strlen is encoded in lowest 6 bits (max strlen is 63)
-  // character encoding info is in bits 7 and 8
-  // The other bits are used to encoded character data.
-  private final long bits1;
-  // bits2 encodes character data
-  private final long bits2;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -375,28 +384,28 @@ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegio
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
-    long tmpBits2 = this.bits2;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+    long tempBits2 = this.bits2;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 7) {
-          tmpBits1 >>= 8;
-          chars[i] = (char) (tmpBits1 & 0x00ff);
+          tempBits1 >>= 8;
+          chars[i] = (char) (tempBits1 & 0x00ff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00ff);
-          tmpBits2 >>= 8;
+          chars[i] = (char) (tempBits2 & 0x00ff);
+          tempBits2 >>= 8;
         }
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 3) {
-          tmpBits1 >>= 16;
-          chars[i] = (char) (tmpBits1 & 0x00FFff);
+          tempBits1 >>= 16;
+          chars[i] = (char) (tempBits1 & 0x00FFff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00FFff);
-          tmpBits2 >>= 16;
+          chars[i] = (char) (tempBits2 & 0x00FFff);
+          tempBits2 >>= 16;
         }
       }
     }
@@ -405,38 +414,38 @@ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegio
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
-        long tmpBits2 = this.bits2;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+        long tempBits2 = this.bits2;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 7) {
-              tmpBits1 >>= 8;
-              c = (char) (tmpBits1 & 0x00ff);
+              tempBits1 >>= 8;
+              character = (char) (tempBits1 & 0x00ff);
             } else {
-              c = (char) (tmpBits2 & 0x00ff);
-              tmpBits2 >>= 8;
+              character = (char) (tempBits2 & 0x00ff);
+              tempBits2 >>= 8;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 3) {
-              tmpBits1 >>= 16;
-              c = (char) (tmpBits1 & 0x00FFff);
+              tempBits1 >>= 16;
+              character = (char) (tempBits1 & 0x00FFff);
             } else {
-              c = (char) (tmpBits2 & 0x00FFff);
-              tmpBits2 >>= 16;
+              character = (char) (tempBits2 & 0x00FFff);
+              tempBits2 >>= 16;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapUUIDKey.java
index 4391cf9..334af2a 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapUUIDKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryHeapUUIDKey.java
@@ -20,36 +20,60 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryHeapUUIDKey extends VMStatsDiskLRURegionEntryHeap {
-  public VMStatsDiskLRURegionEntryHeapUUIDKey(RegionEntryContext context, UUID key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapUUIDKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapUUIDKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapUUIDKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapUUIDKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapUUIDKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapUUIDKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long keyMostSigBits;
+  private final long keyLeastSigBits;
+
+  public VMStatsDiskLRURegionEntryHeapUUIDKey(final RegionEntryContext context, final UUID key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -58,77 +82,65 @@ public class VMStatsDiskLRURegionEntryHeapUUIDKey extends VMStatsDiskLRURegionEn
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapUUIDKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapUUIDKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -137,48 +149,43 @@ public class VMStatsDiskLRURegionEntryHeapUUIDKey extends VMStatsDiskLRURegionEn
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -186,6 +193,7 @@ public class VMStatsDiskLRURegionEntryHeapUUIDKey extends VMStatsDiskLRURegionEn
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -195,48 +203,57 @@ public class VMStatsDiskLRURegionEntryHeapUUIDKey extends VMStatsDiskLRURegionEn
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -247,12 +264,12 @@ public class VMStatsDiskLRURegionEntryHeapUUIDKey extends VMStatsDiskLRURegionEn
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -260,28 +277,20 @@ public class VMStatsDiskLRURegionEntryHeapUUIDKey extends VMStatsDiskLRURegionEn
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapUUIDKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapUUIDKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapUUIDKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapUUIDKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -296,24 +305,24 @@ public class VMStatsDiskLRURegionEntryHeapUUIDKey extends VMStatsDiskLRURegionEn
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -323,20 +332,17 @@ public class VMStatsDiskLRURegionEntryHeapUUIDKey extends VMStatsDiskLRURegionEn
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long keyMostSigBits;
-  private final long keyLeastSigBits;
-
   @Override
   public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof UUID) {
-      UUID uuid = (UUID) k;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof UUID) {
+      UUID uuid = (UUID) key;
       return uuid.getLeastSignificantBits() == this.keyLeastSigBits
           && uuid.getMostSignificantBits() == this.keyMostSigBits;
     }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapIntKey.java
index 0123a3d..d2fd9b3 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapIntKey.java
@@ -19,13 +19,13 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -35,59 +35,78 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegionEntryOffHeap {
-  public VMStatsDiskLRURegionEntryOffHeapIntKey(RegionEntryContext context, int key,
-      @Retained Object value) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    initialize(context, value);
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapIntKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapIntKey.class,
+          "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapIntKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapIntKey.class,
-          "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
+   */
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapIntKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapIntKey.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
    */
-  private final static AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapIntKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapIntKey.class, "ohAddress");
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapIntKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapIntKey.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapIntKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapIntKey.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final int key;
 
+  public VMStatsDiskLRURegionEntryOffHeapIntKey(final RegionEntryContext context, final int key,
+      @Retained final Object value) {
+    super(context, (value instanceof RecoveredEntry ? null : value));
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    initialize(context, value);
+    this.key = key;
+  }
+
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -101,24 +120,24 @@ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegion
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -129,61 +148,58 @@ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegion
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -192,48 +208,43 @@ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegion
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -241,6 +252,7 @@ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegion
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -250,48 +262,57 @@ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegion
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -302,12 +323,12 @@ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegion
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -315,30 +336,20 @@ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegion
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapIntKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapIntKey.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapIntKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapIntKey.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -353,24 +364,24 @@ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegion
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -380,19 +391,17 @@ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegion
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final int key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapLongKey.java
index 1db2dd9..40675b2 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapLongKey.java
@@ -19,13 +19,13 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -35,59 +35,78 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegionEntryOffHeap {
-  public VMStatsDiskLRURegionEntryOffHeapLongKey(RegionEntryContext context, long key,
-      @Retained Object value) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    initialize(context, value);
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapLongKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapLongKey.class,
+          "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapLongKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapLongKey.class,
-          "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
+   */
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapLongKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapLongKey.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
    */
-  private final static AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapLongKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapLongKey.class, "ohAddress");
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapLongKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapLongKey.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapLongKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapLongKey.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long key;
 
+  public VMStatsDiskLRURegionEntryOffHeapLongKey(final RegionEntryContext context, final long key,
+      @Retained final Object value) {
+    super(context, (value instanceof RecoveredEntry ? null : value));
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    initialize(context, value);
+    this.key = key;
+  }
+
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -101,24 +120,24 @@ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegio
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -129,61 +148,58 @@ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegio
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -192,48 +208,43 @@ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegio
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -241,6 +252,7 @@ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegio
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -250,48 +262,57 @@ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegio
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -302,12 +323,12 @@ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegio
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -315,30 +336,20 @@ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegio
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapLongKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapLongKey.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapLongKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapLongKey.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -353,24 +364,24 @@ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegio
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -380,19 +391,17 @@ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegio
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapObjectKey.java
index 2b450f3..62419d9 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapObjectKey.java
@@ -19,13 +19,13 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -35,60 +35,78 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRURegionEntryOffHeap {
-  public VMStatsDiskLRURegionEntryOffHeapObjectKey(RegionEntryContext context, Object key,
-      @Retained Object value) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    initialize(context, value);
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapObjectKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapObjectKey.class,
+          "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapObjectKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapObjectKey.class,
-          "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapObjectKey> ohAddrUpdater =
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapObjectKey> OFF_HEAP_ADDRESS_UPDATER =
       AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapObjectKey.class,
-          "ohAddress");
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapObjectKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapObjectKey.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapObjectKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapObjectKey.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final Object key;
+
+  public VMStatsDiskLRURegionEntryOffHeapObjectKey(final RegionEntryContext context,
+      final Object key, @Retained final Object value) {
+    super(context, (value instanceof RecoveredEntry ? null : value));
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    initialize(context, value);
+    this.key = key;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -102,24 +120,24 @@ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRUReg
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -130,61 +148,58 @@ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRUReg
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -193,48 +208,43 @@ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRUReg
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -242,6 +252,7 @@ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRUReg
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -251,48 +262,57 @@ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRUReg
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -303,12 +323,12 @@ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRUReg
     return getKey();
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -316,30 +336,20 @@ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRUReg
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapObjectKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapObjectKey.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapObjectKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapObjectKey.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -354,24 +364,24 @@ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRUReg
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -381,10 +391,8 @@ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRUReg
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final Object key;
-
   @Override
   public Object getKey() {
     return this.key;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapStringKey1.java
index 0840ef5..276dee5 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapStringKey1.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapStringKey1.java
@@ -19,13 +19,13 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -35,77 +35,95 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURegionEntryOffHeap {
-  public VMStatsDiskLRURegionEntryOffHeapStringKey1(RegionEntryContext context, String key,
-      @Retained Object value, boolean byteEncode) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    initialize(context, value);
-    // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    if (byteEncode) {
-      for (int i = key.length() - 1; i >= 0; i--) {
-        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
-        // keep findbugs happy.
-        tmpBits1 |= (byte) key.charAt(i) & 0xff;
-        tmpBits1 <<= 8;
-      }
-      tmpBits1 |= 1 << 6;
-    } else {
-      for (int i = key.length() - 1; i >= 0; i--) {
-        tmpBits1 |= key.charAt(i);
-        tmpBits1 <<= 16;
-      }
-    }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey1> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey1.class,
+          "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey1> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey1.class,
-          "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey1> ohAddrUpdater =
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey1> OFF_HEAP_ADDRESS_UPDATER =
       AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey1.class,
-          "ohAddress");
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey1> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey1.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey1> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey1.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long bits1;
+
+  public VMStatsDiskLRURegionEntryOffHeapStringKey1(final RegionEntryContext context,
+      final String key, @Retained final Object value, final boolean byteEncode) {
+    super(context, (value instanceof RecoveredEntry ? null : value));
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    initialize(context, value);
+    // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
+    long tempBits1 = 0L;
+    if (byteEncode) {
+      for (int i = key.length() - 1; i >= 0; i--) {
+        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
+        // keep findbugs happy.
+        tempBits1 |= (byte) key.charAt(i) & 0xff;
+        tempBits1 <<= 8;
+      }
+      tempBits1 |= 1 << 6;
+    } else {
+      for (int i = key.length() - 1; i >= 0; i--) {
+        tempBits1 |= key.charAt(i);
+        tempBits1 <<= 16;
+      }
+    }
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -119,24 +137,24 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -147,61 +165,58 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -210,48 +225,43 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -259,6 +269,7 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -268,48 +279,57 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -320,12 +340,12 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -333,30 +353,20 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey1> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey1.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey1> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey1.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -371,24 +381,24 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -398,10 +408,8 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long bits1;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -414,18 +422,18 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 8;
-        chars[i] = (char) (tmpBits1 & 0x00ff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 8;
+        chars[i] = (char) (tempBits1 & 0x00ff);
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
       }
     }
     return new String(chars);
@@ -433,25 +441,25 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURe
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 8;
-            char c = (char) (tmpBits1 & 0x00ff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 8;
+            char character = (char) (tempBits1 & 0x00ff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 16;
-            char c = (char) (tmpBits1 & 0x00FFff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 16;
+            char character = (char) (tempBits1 & 0x00FFff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapStringKey2.java
index 1ba56ed..3189bb2 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapStringKey2.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapStringKey2.java
@@ -19,13 +19,13 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -35,89 +35,116 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURegionEntryOffHeap {
-  public VMStatsDiskLRURegionEntryOffHeapStringKey2(RegionEntryContext context, String key,
-      @Retained Object value, boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey2> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey2.class,
+          "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  // --------------------------------------- offheap fields ---------------------------------------
+  /**
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
+   */
+  @SuppressWarnings("unused")
+  @Retained
+  @Released
+  private volatile long offHeapAddress;
+  /**
+   * I needed to add this because I wanted clear to call setValue which normally can only be called
+   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
+   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
+   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
+   */
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey2> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey2.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey2> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey2.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey2> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey2.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  /**
+   * strlen is encoded in lowest 6 bits (max strlen is 63)<br>
+   * character encoding info is in bits 7 and 8<br>
+   * The other bits are used to encoded character data.
+   */
+  private final long bits1;
+  /**
+   * bits2 encodes character data
+   */
+  private final long bits2;
+
+  public VMStatsDiskLRURegionEntryOffHeapStringKey2(final RegionEntryContext context,
+      final String key, @Retained final Object value, final boolean byteEncode) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    long tmpBits2 = 0L;
+    long tempBits1 = 0L;
+    long tempBits2 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
         if (i < 7) {
-          tmpBits1 |= (byte) key.charAt(i) & 0xff;
-          tmpBits1 <<= 8;
+          tempBits1 |= (byte) key.charAt(i) & 0xff;
+          tempBits1 <<= 8;
         } else {
-          tmpBits2 <<= 8;
-          tmpBits2 |= (byte) key.charAt(i) & 0xff;
+          tempBits2 <<= 8;
+          tempBits2 |= (byte) key.charAt(i) & 0xff;
         }
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
         if (i < 3) {
-          tmpBits1 |= key.charAt(i);
-          tmpBits1 <<= 16;
+          tempBits1 |= key.charAt(i);
+          tempBits1 <<= 16;
         } else {
-          tmpBits2 <<= 16;
-          tmpBits2 |= key.charAt(i);
+          tempBits2 <<= 16;
+          tempBits2 |= key.charAt(i);
         }
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-    this.bits2 = tmpBits2;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+    this.bits2 = tempBits2;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey2> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey2.class,
-          "lastModified");
-  /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
-   */
-  @SuppressWarnings("unused")
-  @Retained
-  @Released
-  private volatile long ohAddress;
-  /**
-   * I needed to add this because I wanted clear to call setValue which normally can only be called
-   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
-   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
-   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
-   */
-  private final static AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey2> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey2.class,
-          "ohAddress");
-
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -131,24 +158,24 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -159,61 +186,58 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -222,48 +246,43 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -271,6 +290,7 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -280,48 +300,57 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -332,12 +361,12 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -345,30 +374,20 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey2> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey2.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapStringKey2> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapStringKey2.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -383,24 +402,24 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -410,15 +429,8 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  // strlen is encoded in lowest 6 bits (max strlen is 63)
-  // character encoding info is in bits 7 and 8
-  // The other bits are used to encoded character data.
-  private final long bits1;
-  // bits2 encodes character data
-  private final long bits2;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -431,28 +443,28 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
-    long tmpBits2 = this.bits2;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+    long tempBits2 = this.bits2;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 7) {
-          tmpBits1 >>= 8;
-          chars[i] = (char) (tmpBits1 & 0x00ff);
+          tempBits1 >>= 8;
+          chars[i] = (char) (tempBits1 & 0x00ff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00ff);
-          tmpBits2 >>= 8;
+          chars[i] = (char) (tempBits2 & 0x00ff);
+          tempBits2 >>= 8;
         }
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 3) {
-          tmpBits1 >>= 16;
-          chars[i] = (char) (tmpBits1 & 0x00FFff);
+          tempBits1 >>= 16;
+          chars[i] = (char) (tempBits1 & 0x00FFff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00FFff);
-          tmpBits2 >>= 16;
+          chars[i] = (char) (tempBits2 & 0x00FFff);
+          tempBits2 >>= 16;
         }
       }
     }
@@ -461,38 +473,38 @@ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURe
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
-        long tmpBits2 = this.bits2;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+        long tempBits2 = this.bits2;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 7) {
-              tmpBits1 >>= 8;
-              c = (char) (tmpBits1 & 0x00ff);
+              tempBits1 >>= 8;
+              character = (char) (tempBits1 & 0x00ff);
             } else {
-              c = (char) (tmpBits2 & 0x00ff);
-              tmpBits2 >>= 8;
+              character = (char) (tempBits2 & 0x00ff);
+              tempBits2 >>= 8;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 3) {
-              tmpBits1 >>= 16;
-              c = (char) (tmpBits1 & 0x00FFff);
+              tempBits1 >>= 16;
+              character = (char) (tempBits1 & 0x00FFff);
             } else {
-              c = (char) (tmpBits2 & 0x00FFff);
-              tmpBits2 >>= 16;
+              character = (char) (tempBits2 & 0x00FFff);
+              tempBits2 >>= 16;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapUUIDKey.java
index 65bf26a..9387dde 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapUUIDKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskLRURegionEntryOffHeapUUIDKey.java
@@ -20,13 +20,13 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -36,60 +36,80 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegionEntryOffHeap {
-  public VMStatsDiskLRURegionEntryOffHeapUUIDKey(RegionEntryContext context, UUID key,
-      @Retained Object value) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    initialize(context, value);
-    this.keyMostSigBits = key.getMostSignificantBits();
-    this.keyLeastSigBits = key.getLeastSignificantBits();
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapUUIDKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapUUIDKey.class,
+          "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapUUIDKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapUUIDKey.class,
-          "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
+   */
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapUUIDKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapUUIDKey.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
    */
-  private final static AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryOffHeapUUIDKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapUUIDKey.class, "ohAddress");
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapUUIDKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapUUIDKey.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapUUIDKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapUUIDKey.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long keyMostSigBits;
+  private final long keyLeastSigBits;
 
+  public VMStatsDiskLRURegionEntryOffHeapUUIDKey(final RegionEntryContext context, final UUID key,
+      @Retained final Object value) {
+    super(context, (value instanceof RecoveredEntry ? null : value));
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    initialize(context, value);
+    this.keyMostSigBits = key.getMostSignificantBits();
+    this.keyLeastSigBits = key.getLeastSignificantBits();
+  }
+
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -103,24 +123,24 @@ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegio
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -131,61 +151,58 @@ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegio
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -194,48 +211,43 @@ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegio
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -243,6 +255,7 @@ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegio
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -252,48 +265,57 @@ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegio
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -304,12 +326,12 @@ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegio
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -317,30 +339,20 @@ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegio
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapUUIDKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapUUIDKey.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryOffHeapUUIDKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryOffHeapUUIDKey.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -355,24 +367,24 @@ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegio
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -382,20 +394,17 @@ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegio
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long keyMostSigBits;
-  private final long keyLeastSigBits;
-
   @Override
   public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof UUID) {
-      UUID uuid = (UUID) k;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof UUID) {
+      UUID uuid = (UUID) key;
       return uuid.getLeastSignificantBits() == this.keyLeastSigBits
           && uuid.getMostSignificantBits() == this.keyMostSigBits;
     }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapIntKey.java
index a083182..b852a74 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapIntKey.java
@@ -19,33 +19,56 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryHeapIntKey extends VMStatsDiskRegionEntryHeap {
-  public VMStatsDiskRegionEntryHeapIntKey(RegionEntryContext context, int key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapIntKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapIntKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapIntKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapIntKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapIntKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapIntKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final int key;
+
+  public VMStatsDiskRegionEntryHeapIntKey(final RegionEntryContext context, final int key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -53,101 +76,83 @@ public class VMStatsDiskRegionEntryHeapIntKey extends VMStatsDiskRegionEntryHeap
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapIntKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapIntKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -155,28 +160,20 @@ public class VMStatsDiskRegionEntryHeapIntKey extends VMStatsDiskRegionEntryHeap
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapIntKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapIntKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapIntKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapIntKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -191,24 +188,24 @@ public class VMStatsDiskRegionEntryHeapIntKey extends VMStatsDiskRegionEntryHeap
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -218,19 +215,17 @@ public class VMStatsDiskRegionEntryHeapIntKey extends VMStatsDiskRegionEntryHeap
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final int key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapLongKey.java
index 1089f71..6207c43 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapLongKey.java
@@ -19,33 +19,56 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryHeapLongKey extends VMStatsDiskRegionEntryHeap {
-  public VMStatsDiskRegionEntryHeapLongKey(RegionEntryContext context, long key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapLongKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapLongKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapLongKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapLongKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapLongKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapLongKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long key;
+
+  public VMStatsDiskRegionEntryHeapLongKey(final RegionEntryContext context, final long key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -53,101 +76,83 @@ public class VMStatsDiskRegionEntryHeapLongKey extends VMStatsDiskRegionEntryHea
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapLongKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapLongKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -155,28 +160,20 @@ public class VMStatsDiskRegionEntryHeapLongKey extends VMStatsDiskRegionEntryHea
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapLongKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapLongKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapLongKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapLongKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -191,24 +188,24 @@ public class VMStatsDiskRegionEntryHeapLongKey extends VMStatsDiskRegionEntryHea
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -218,19 +215,17 @@ public class VMStatsDiskRegionEntryHeapLongKey extends VMStatsDiskRegionEntryHea
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapObjectKey.java
index 616c093..98bc662 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapObjectKey.java
@@ -19,33 +19,56 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryHeapObjectKey extends VMStatsDiskRegionEntryHeap {
-  public VMStatsDiskRegionEntryHeapObjectKey(RegionEntryContext context, Object key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapObjectKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapObjectKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapObjectKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapObjectKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapObjectKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapObjectKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final Object key;
+
+  public VMStatsDiskRegionEntryHeapObjectKey(final RegionEntryContext context, final Object key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -53,101 +76,83 @@ public class VMStatsDiskRegionEntryHeapObjectKey extends VMStatsDiskRegionEntryH
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapObjectKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapObjectKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -155,28 +160,20 @@ public class VMStatsDiskRegionEntryHeapObjectKey extends VMStatsDiskRegionEntryH
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapObjectKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapObjectKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapObjectKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapObjectKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -191,24 +188,24 @@ public class VMStatsDiskRegionEntryHeapObjectKey extends VMStatsDiskRegionEntryH
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -218,10 +215,8 @@ public class VMStatsDiskRegionEntryHeapObjectKey extends VMStatsDiskRegionEntryH
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final Object key;
-
   @Override
   public Object getKey() {
     return this.key;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapStringKey1.java
index 6908bd8..f6a064d 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapStringKey1.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapStringKey1.java
@@ -19,153 +19,157 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryHeapStringKey1 extends VMStatsDiskRegionEntryHeap {
-  public VMStatsDiskRegionEntryHeapStringKey1(RegionEntryContext context, String key, Object value,
-      boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapStringKey1> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey1.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapStringKey1> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey1.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapStringKey1> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey1.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long bits1;
+
+  public VMStatsDiskRegionEntryHeapStringKey1(final RegionEntryContext context, final String key,
+      final Object value, final boolean byteEncode) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
+    long tempBits1 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
-        tmpBits1 |= (byte) key.charAt(i) & 0xff;
-        tmpBits1 <<= 8;
+        tempBits1 |= (byte) key.charAt(i) & 0xff;
+        tempBits1 <<= 8;
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
-        tmpBits1 |= key.charAt(i);
-        tmpBits1 <<= 16;
+        tempBits1 |= key.charAt(i);
+        tempBits1 <<= 16;
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapStringKey1> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey1.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -173,28 +177,20 @@ public class VMStatsDiskRegionEntryHeapStringKey1 extends VMStatsDiskRegionEntry
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapStringKey1> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey1.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapStringKey1> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey1.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -209,24 +205,24 @@ public class VMStatsDiskRegionEntryHeapStringKey1 extends VMStatsDiskRegionEntry
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -236,10 +232,8 @@ public class VMStatsDiskRegionEntryHeapStringKey1 extends VMStatsDiskRegionEntry
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long bits1;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -252,18 +246,18 @@ public class VMStatsDiskRegionEntryHeapStringKey1 extends VMStatsDiskRegionEntry
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 8;
-        chars[i] = (char) (tmpBits1 & 0x00ff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 8;
+        chars[i] = (char) (tempBits1 & 0x00ff);
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
       }
     }
     return new String(chars);
@@ -271,25 +265,25 @@ public class VMStatsDiskRegionEntryHeapStringKey1 extends VMStatsDiskRegionEntry
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 8;
-            char c = (char) (tmpBits1 & 0x00ff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 8;
+            char character = (char) (tempBits1 & 0x00ff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 16;
-            char c = (char) (tmpBits1 & 0x00FFff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 16;
+            char character = (char) (tempBits1 & 0x00FFff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapStringKey2.java
index f1844a2..1e2bec4 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapStringKey2.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapStringKey2.java
@@ -19,165 +19,178 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryHeapStringKey2 extends VMStatsDiskRegionEntryHeap {
-  public VMStatsDiskRegionEntryHeapStringKey2(RegionEntryContext context, String key, Object value,
-      boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapStringKey2> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey2.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapStringKey2> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey2.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapStringKey2> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey2.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  /**
+   * strlen is encoded in lowest 6 bits (max strlen is 63)<br>
+   * character encoding info is in bits 7 and 8<br>
+   * The other bits are used to encoded character data.
+   */
+  private final long bits1;
+  /**
+   * bits2 encodes character data
+   */
+  private final long bits2;
+
+  public VMStatsDiskRegionEntryHeapStringKey2(final RegionEntryContext context, final String key,
+      final Object value, final boolean byteEncode) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    long tmpBits2 = 0L;
+    long tempBits1 = 0L;
+    long tempBits2 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
         if (i < 7) {
-          tmpBits1 |= (byte) key.charAt(i) & 0xff;
-          tmpBits1 <<= 8;
+          tempBits1 |= (byte) key.charAt(i) & 0xff;
+          tempBits1 <<= 8;
         } else {
-          tmpBits2 <<= 8;
-          tmpBits2 |= (byte) key.charAt(i) & 0xff;
+          tempBits2 <<= 8;
+          tempBits2 |= (byte) key.charAt(i) & 0xff;
         }
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
         if (i < 3) {
-          tmpBits1 |= key.charAt(i);
-          tmpBits1 <<= 16;
+          tempBits1 |= key.charAt(i);
+          tempBits1 <<= 16;
         } else {
-          tmpBits2 <<= 16;
-          tmpBits2 |= key.charAt(i);
+          tempBits2 <<= 16;
+          tempBits2 |= key.charAt(i);
         }
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-    this.bits2 = tmpBits2;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+    this.bits2 = tempBits2;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapStringKey2> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey2.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -185,28 +198,20 @@ public class VMStatsDiskRegionEntryHeapStringKey2 extends VMStatsDiskRegionEntry
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapStringKey2> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey2.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapStringKey2> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapStringKey2.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -221,24 +226,24 @@ public class VMStatsDiskRegionEntryHeapStringKey2 extends VMStatsDiskRegionEntry
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -248,15 +253,8 @@ public class VMStatsDiskRegionEntryHeapStringKey2 extends VMStatsDiskRegionEntry
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  // strlen is encoded in lowest 6 bits (max strlen is 63)
-  // character encoding info is in bits 7 and 8
-  // The other bits are used to encoded character data.
-  private final long bits1;
-  // bits2 encodes character data
-  private final long bits2;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -269,28 +267,28 @@ public class VMStatsDiskRegionEntryHeapStringKey2 extends VMStatsDiskRegionEntry
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
-    long tmpBits2 = this.bits2;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+    long tempBits2 = this.bits2;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 7) {
-          tmpBits1 >>= 8;
-          chars[i] = (char) (tmpBits1 & 0x00ff);
+          tempBits1 >>= 8;
+          chars[i] = (char) (tempBits1 & 0x00ff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00ff);
-          tmpBits2 >>= 8;
+          chars[i] = (char) (tempBits2 & 0x00ff);
+          tempBits2 >>= 8;
         }
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 3) {
-          tmpBits1 >>= 16;
-          chars[i] = (char) (tmpBits1 & 0x00FFff);
+          tempBits1 >>= 16;
+          chars[i] = (char) (tempBits1 & 0x00FFff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00FFff);
-          tmpBits2 >>= 16;
+          chars[i] = (char) (tempBits2 & 0x00FFff);
+          tempBits2 >>= 16;
         }
       }
     }
@@ -299,38 +297,38 @@ public class VMStatsDiskRegionEntryHeapStringKey2 extends VMStatsDiskRegionEntry
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
-        long tmpBits2 = this.bits2;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+        long tempBits2 = this.bits2;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 7) {
-              tmpBits1 >>= 8;
-              c = (char) (tmpBits1 & 0x00ff);
+              tempBits1 >>= 8;
+              character = (char) (tempBits1 & 0x00ff);
             } else {
-              c = (char) (tmpBits2 & 0x00ff);
-              tmpBits2 >>= 8;
+              character = (char) (tempBits2 & 0x00ff);
+              tempBits2 >>= 8;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 3) {
-              tmpBits1 >>= 16;
-              c = (char) (tmpBits1 & 0x00FFff);
+              tempBits1 >>= 16;
+              character = (char) (tempBits1 & 0x00FFff);
             } else {
-              c = (char) (tmpBits2 & 0x00FFff);
-              tmpBits2 >>= 16;
+              character = (char) (tempBits2 & 0x00FFff);
+              tempBits2 >>= 16;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapUUIDKey.java
index a1a101b..0241eff 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapUUIDKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryHeapUUIDKey.java
@@ -20,33 +20,57 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryHeapUUIDKey extends VMStatsDiskRegionEntryHeap {
-  public VMStatsDiskRegionEntryHeapUUIDKey(RegionEntryContext context, UUID key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapUUIDKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapUUIDKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapUUIDKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapUUIDKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapUUIDKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapUUIDKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long keyMostSigBits;
+  private final long keyLeastSigBits;
+
+  public VMStatsDiskRegionEntryHeapUUIDKey(final RegionEntryContext context, final UUID key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -55,101 +79,83 @@ public class VMStatsDiskRegionEntryHeapUUIDKey extends VMStatsDiskRegionEntryHea
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryHeapUUIDKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapUUIDKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -157,28 +163,20 @@ public class VMStatsDiskRegionEntryHeapUUIDKey extends VMStatsDiskRegionEntryHea
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapUUIDKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapUUIDKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryHeapUUIDKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryHeapUUIDKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -193,24 +191,24 @@ public class VMStatsDiskRegionEntryHeapUUIDKey extends VMStatsDiskRegionEntryHea
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -220,20 +218,17 @@ public class VMStatsDiskRegionEntryHeapUUIDKey extends VMStatsDiskRegionEntryHea
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long keyMostSigBits;
-  private final long keyLeastSigBits;
-
   @Override
   public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof UUID) {
-      UUID uuid = (UUID) k;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof UUID) {
+      UUID uuid = (UUID) key;
       return uuid.getLeastSignificantBits() == this.keyLeastSigBits
           && uuid.getMostSignificantBits() == this.keyMostSigBits;
     }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapIntKey.java
index 85e6daf..1714b5d 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapIntKey.java
@@ -19,11 +19,11 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.cache.Token;
 import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper;
@@ -32,58 +32,75 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryOffHeapIntKey extends VMStatsDiskRegionEntryOffHeap {
-  public VMStatsDiskRegionEntryOffHeapIntKey(RegionEntryContext context, int key,
-      @Retained Object value) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    initialize(context, value);
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapIntKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapIntKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapIntKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapIntKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapIntKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapIntKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapIntKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapIntKey.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapIntKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapIntKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapIntKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapIntKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final int key;
+
+  public VMStatsDiskRegionEntryOffHeapIntKey(final RegionEntryContext context, final int key,
+      @Retained final Object value) {
+    super(context, (value instanceof RecoveredEntry ? null : value));
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    initialize(context, value);
+    this.key = key;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -97,24 +114,24 @@ public class VMStatsDiskRegionEntryOffHeapIntKey extends VMStatsDiskRegionEntryO
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -125,85 +142,76 @@ public class VMStatsDiskRegionEntryOffHeapIntKey extends VMStatsDiskRegionEntryO
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -211,28 +219,20 @@ public class VMStatsDiskRegionEntryOffHeapIntKey extends VMStatsDiskRegionEntryO
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapIntKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapIntKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapIntKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapIntKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -247,24 +247,24 @@ public class VMStatsDiskRegionEntryOffHeapIntKey extends VMStatsDiskRegionEntryO
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -274,19 +274,17 @@ public class VMStatsDiskRegionEntryOffHeapIntKey extends VMStatsDiskRegionEntryO
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final int key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapLongKey.java
index 40efae9..260cd92 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapLongKey.java
@@ -19,11 +19,11 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.cache.Token;
 import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper;
@@ -32,58 +32,75 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryOffHeapLongKey extends VMStatsDiskRegionEntryOffHeap {
-  public VMStatsDiskRegionEntryOffHeapLongKey(RegionEntryContext context, long key,
-      @Retained Object value) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    initialize(context, value);
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapLongKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapLongKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapLongKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapLongKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapLongKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapLongKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapLongKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapLongKey.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapLongKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapLongKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapLongKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapLongKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long key;
+
+  public VMStatsDiskRegionEntryOffHeapLongKey(final RegionEntryContext context, final long key,
+      @Retained final Object value) {
+    super(context, (value instanceof RecoveredEntry ? null : value));
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    initialize(context, value);
+    this.key = key;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -97,24 +114,24 @@ public class VMStatsDiskRegionEntryOffHeapLongKey extends VMStatsDiskRegionEntry
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -125,85 +142,76 @@ public class VMStatsDiskRegionEntryOffHeapLongKey extends VMStatsDiskRegionEntry
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -211,28 +219,20 @@ public class VMStatsDiskRegionEntryOffHeapLongKey extends VMStatsDiskRegionEntry
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapLongKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapLongKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapLongKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapLongKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -247,24 +247,24 @@ public class VMStatsDiskRegionEntryOffHeapLongKey extends VMStatsDiskRegionEntry
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -274,19 +274,17 @@ public class VMStatsDiskRegionEntryOffHeapLongKey extends VMStatsDiskRegionEntry
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapObjectKey.java
index ef638d3..9a5ee2f 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapObjectKey.java
@@ -19,11 +19,11 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.cache.Token;
 import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper;
@@ -32,59 +32,78 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryOffHeapObjectKey extends VMStatsDiskRegionEntryOffHeap {
-  public VMStatsDiskRegionEntryOffHeapObjectKey(RegionEntryContext context, Object key,
-      @Retained Object value) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    initialize(context, value);
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapObjectKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapObjectKey.class,
+          "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapObjectKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapObjectKey.class,
-          "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapObjectKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapObjectKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapObjectKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapObjectKey.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapObjectKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapObjectKey.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapObjectKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapObjectKey.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final Object key;
 
+  public VMStatsDiskRegionEntryOffHeapObjectKey(final RegionEntryContext context, final Object key,
+      @Retained final Object value) {
+    super(context, (value instanceof RecoveredEntry ? null : value));
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    initialize(context, value);
+    this.key = key;
+  }
+
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -98,24 +117,24 @@ public class VMStatsDiskRegionEntryOffHeapObjectKey extends VMStatsDiskRegionEnt
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -126,85 +145,76 @@ public class VMStatsDiskRegionEntryOffHeapObjectKey extends VMStatsDiskRegionEnt
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -212,30 +222,20 @@ public class VMStatsDiskRegionEntryOffHeapObjectKey extends VMStatsDiskRegionEnt
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapObjectKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapObjectKey.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapObjectKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapObjectKey.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -250,24 +250,24 @@ public class VMStatsDiskRegionEntryOffHeapObjectKey extends VMStatsDiskRegionEnt
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -277,10 +277,8 @@ public class VMStatsDiskRegionEntryOffHeapObjectKey extends VMStatsDiskRegionEnt
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final Object key;
-
   @Override
   public Object getKey() {
     return this.key;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapStringKey1.java
index ee7b340..f0d6beb 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapStringKey1.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapStringKey1.java
@@ -19,11 +19,11 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.cache.Token;
 import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper;
@@ -32,76 +32,95 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryOffHeapStringKey1 extends VMStatsDiskRegionEntryOffHeap {
-  public VMStatsDiskRegionEntryOffHeapStringKey1(RegionEntryContext context, String key,
-      @Retained Object value, boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey1> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey1.class,
+          "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  // --------------------------------------- offheap fields ---------------------------------------
+  /**
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
+   */
+  @SuppressWarnings("unused")
+  @Retained
+  @Released
+  private volatile long offHeapAddress;
+  /**
+   * I needed to add this because I wanted clear to call setValue which normally can only be called
+   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
+   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
+   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
+   */
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey1> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey1.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey1> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey1.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey1> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey1.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long bits1;
+
+  public VMStatsDiskRegionEntryOffHeapStringKey1(final RegionEntryContext context, final String key,
+      @Retained final Object value, final boolean byteEncode) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
+    long tempBits1 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
-        tmpBits1 |= (byte) key.charAt(i) & 0xff;
-        tmpBits1 <<= 8;
+        tempBits1 |= (byte) key.charAt(i) & 0xff;
+        tempBits1 <<= 8;
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
-        tmpBits1 |= key.charAt(i);
-        tmpBits1 <<= 16;
+        tempBits1 |= key.charAt(i);
+        tempBits1 <<= 16;
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey1> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey1.class,
-          "lastModified");
-  /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
-   */
-  @SuppressWarnings("unused")
-  @Retained
-  @Released
-  private volatile long ohAddress;
-  /**
-   * I needed to add this because I wanted clear to call setValue which normally can only be called
-   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
-   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
-   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
-   */
-  private final static AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey1> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey1.class, "ohAddress");
-
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -115,24 +134,24 @@ public class VMStatsDiskRegionEntryOffHeapStringKey1 extends VMStatsDiskRegionEn
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -143,85 +162,76 @@ public class VMStatsDiskRegionEntryOffHeapStringKey1 extends VMStatsDiskRegionEn
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -229,30 +239,20 @@ public class VMStatsDiskRegionEntryOffHeapStringKey1 extends VMStatsDiskRegionEn
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey1> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey1.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey1> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey1.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -267,24 +267,24 @@ public class VMStatsDiskRegionEntryOffHeapStringKey1 extends VMStatsDiskRegionEn
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -294,10 +294,8 @@ public class VMStatsDiskRegionEntryOffHeapStringKey1 extends VMStatsDiskRegionEn
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long bits1;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -310,18 +308,18 @@ public class VMStatsDiskRegionEntryOffHeapStringKey1 extends VMStatsDiskRegionEn
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 8;
-        chars[i] = (char) (tmpBits1 & 0x00ff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 8;
+        chars[i] = (char) (tempBits1 & 0x00ff);
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
       }
     }
     return new String(chars);
@@ -329,25 +327,25 @@ public class VMStatsDiskRegionEntryOffHeapStringKey1 extends VMStatsDiskRegionEn
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 8;
-            char c = (char) (tmpBits1 & 0x00ff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 8;
+            char character = (char) (tempBits1 & 0x00ff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 16;
-            char c = (char) (tmpBits1 & 0x00FFff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 16;
+            char character = (char) (tempBits1 & 0x00FFff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapStringKey2.java
index 1e571b7..87c0265 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapStringKey2.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapStringKey2.java
@@ -19,11 +19,11 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.cache.Token;
 import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper;
@@ -32,88 +32,116 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEntryOffHeap {
-  public VMStatsDiskRegionEntryOffHeapStringKey2(RegionEntryContext context, String key,
-      @Retained Object value, boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey2> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class,
+          "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  // --------------------------------------- offheap fields ---------------------------------------
+  /**
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
+   */
+  @SuppressWarnings("unused")
+  @Retained
+  @Released
+  private volatile long offHeapAddress;
+  /**
+   * I needed to add this because I wanted clear to call setValue which normally can only be called
+   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
+   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
+   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
+   */
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey2> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey2> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey2> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  /**
+   * strlen is encoded in lowest 6 bits (max strlen is 63)<br>
+   * character encoding info is in bits 7 and 8<br>
+   * The other bits are used to encoded character data.
+   */
+  private final long bits1;
+  /**
+   * bits2 encodes character data
+   */
+  private final long bits2;
+
+  public VMStatsDiskRegionEntryOffHeapStringKey2(final RegionEntryContext context, final String key,
+      @Retained final Object value, final boolean byteEncode) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    long tmpBits2 = 0L;
+    long tempBits1 = 0L;
+    long tempBits2 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
         if (i < 7) {
-          tmpBits1 |= (byte) key.charAt(i) & 0xff;
-          tmpBits1 <<= 8;
+          tempBits1 |= (byte) key.charAt(i) & 0xff;
+          tempBits1 <<= 8;
         } else {
-          tmpBits2 <<= 8;
-          tmpBits2 |= (byte) key.charAt(i) & 0xff;
+          tempBits2 <<= 8;
+          tempBits2 |= (byte) key.charAt(i) & 0xff;
         }
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
         if (i < 3) {
-          tmpBits1 |= key.charAt(i);
-          tmpBits1 <<= 16;
+          tempBits1 |= key.charAt(i);
+          tempBits1 <<= 16;
         } else {
-          tmpBits2 <<= 16;
-          tmpBits2 |= key.charAt(i);
+          tempBits2 <<= 16;
+          tempBits2 |= key.charAt(i);
         }
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-    this.bits2 = tmpBits2;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+    this.bits2 = tempBits2;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey2> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class,
-          "lastModified");
-  /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
-   */
-  @SuppressWarnings("unused")
-  @Retained
-  @Released
-  private volatile long ohAddress;
-  /**
-   * I needed to add this because I wanted clear to call setValue which normally can only be called
-   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
-   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
-   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
-   */
-  private final static AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey2> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class, "ohAddress");
-
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -127,24 +155,24 @@ public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEn
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -155,85 +183,76 @@ public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEn
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -241,30 +260,20 @@ public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEn
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey2> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapStringKey2> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -279,24 +288,24 @@ public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEn
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -306,15 +315,8 @@ public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEn
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  // strlen is encoded in lowest 6 bits (max strlen is 63)
-  // character encoding info is in bits 7 and 8
-  // The other bits are used to encoded character data.
-  private final long bits1;
-  // bits2 encodes character data
-  private final long bits2;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -327,28 +329,28 @@ public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEn
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
-    long tmpBits2 = this.bits2;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+    long tempBits2 = this.bits2;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 7) {
-          tmpBits1 >>= 8;
-          chars[i] = (char) (tmpBits1 & 0x00ff);
+          tempBits1 >>= 8;
+          chars[i] = (char) (tempBits1 & 0x00ff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00ff);
-          tmpBits2 >>= 8;
+          chars[i] = (char) (tempBits2 & 0x00ff);
+          tempBits2 >>= 8;
         }
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 3) {
-          tmpBits1 >>= 16;
-          chars[i] = (char) (tmpBits1 & 0x00FFff);
+          tempBits1 >>= 16;
+          chars[i] = (char) (tempBits1 & 0x00FFff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00FFff);
-          tmpBits2 >>= 16;
+          chars[i] = (char) (tempBits2 & 0x00FFff);
+          tempBits2 >>= 16;
         }
       }
     }
@@ -357,38 +359,38 @@ public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEn
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
-        long tmpBits2 = this.bits2;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+        long tempBits2 = this.bits2;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 7) {
-              tmpBits1 >>= 8;
-              c = (char) (tmpBits1 & 0x00ff);
+              tempBits1 >>= 8;
+              character = (char) (tempBits1 & 0x00ff);
             } else {
-              c = (char) (tmpBits2 & 0x00ff);
-              tmpBits2 >>= 8;
+              character = (char) (tempBits2 & 0x00ff);
+              tempBits2 >>= 8;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 3) {
-              tmpBits1 >>= 16;
-              c = (char) (tmpBits1 & 0x00FFff);
+              tempBits1 >>= 16;
+              character = (char) (tempBits1 & 0x00FFff);
             } else {
-              c = (char) (tmpBits2 & 0x00FFff);
-              tmpBits2 >>= 16;
+              character = (char) (tempBits2 & 0x00FFff);
+              tempBits2 >>= 16;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapUUIDKey.java
index 1c677af..25b7389 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapUUIDKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsDiskRegionEntryOffHeapUUIDKey.java
@@ -20,11 +20,11 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.cache.Token;
 import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper;
@@ -33,59 +33,77 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsDiskRegionEntryOffHeapUUIDKey extends VMStatsDiskRegionEntryOffHeap {
-  public VMStatsDiskRegionEntryOffHeapUUIDKey(RegionEntryContext context, UUID key,
-      @Retained Object value) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    initialize(context, value);
-    this.keyMostSigBits = key.getMostSignificantBits();
-    this.keyLeastSigBits = key.getLeastSignificantBits();
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapUUIDKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapUUIDKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapUUIDKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsDiskRegionEntryOffHeapUUIDKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class,
+          "offHeapAddress");
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapUUIDKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapUUIDKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long keyMostSigBits;
+  private final long keyLeastSigBits;
+
+  public VMStatsDiskRegionEntryOffHeapUUIDKey(final RegionEntryContext context, final UUID key,
+      @Retained final Object value) {
+    super(context, (value instanceof RecoveredEntry ? null : value));
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    initialize(context, value);
+    this.keyMostSigBits = key.getMostSignificantBits();
+    this.keyLeastSigBits = key.getLeastSignificantBits();
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -99,24 +117,24 @@ public class VMStatsDiskRegionEntryOffHeapUUIDKey extends VMStatsDiskRegionEntry
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -127,85 +145,76 @@ public class VMStatsDiskRegionEntryOffHeapUUIDKey extends VMStatsDiskRegionEntry
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext context, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     diskInitialize(context, value);
   }
 
   @Override
-  public int updateAsyncEntrySize(EnableLRU capacityController) {
+  public int updateAsyncEntrySize(final EnableLRU capacityController) {
     throw new IllegalStateException("should never be called");
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -213,28 +222,20 @@ public class VMStatsDiskRegionEntryOffHeapUUIDKey extends VMStatsDiskRegionEntry
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapUUIDKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsDiskRegionEntryOffHeapUUIDKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -249,24 +250,24 @@ public class VMStatsDiskRegionEntryOffHeapUUIDKey extends VMStatsDiskRegionEntry
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -276,20 +277,17 @@ public class VMStatsDiskRegionEntryOffHeapUUIDKey extends VMStatsDiskRegionEntry
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long keyMostSigBits;
-  private final long keyLeastSigBits;
-
   @Override
   public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof UUID) {
-      UUID uuid = (UUID) k;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof UUID) {
+      UUID uuid = (UUID) key;
       return uuid.getLeastSignificantBits() == this.keyLeastSigBits
           && uuid.getMostSignificantBits() == this.keyMostSigBits;
     }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapIntKey.java
index f6a96fd..4824844 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapIntKey.java
@@ -19,104 +19,112 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap {
-  public VMStatsLRURegionEntryHeapIntKey(RegionEntryContext context, int key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapIntKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapIntKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapIntKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapIntKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapIntKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapIntKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final int key;
+
+  public VMStatsLRURegionEntryHeapIntKey(final RegionEntryContext context, final int key,
+      final Object value) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     this.key = key;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapIntKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapIntKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -124,6 +132,7 @@ public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap {
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -133,48 +142,57 @@ public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap {
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -185,12 +203,12 @@ public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap {
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -198,28 +216,20 @@ public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap {
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapIntKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapIntKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapIntKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapIntKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -234,24 +244,24 @@ public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap {
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -261,19 +271,17 @@ public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap {
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final int key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapLongKey.java
index c926d28..f7c13de 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapLongKey.java
@@ -19,104 +19,112 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap {
-  public VMStatsLRURegionEntryHeapLongKey(RegionEntryContext context, long key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapLongKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapLongKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapLongKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapLongKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapLongKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapLongKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long key;
+
+  public VMStatsLRURegionEntryHeapLongKey(final RegionEntryContext context, final long key,
+      final Object value) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     this.key = key;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapLongKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapLongKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -124,6 +132,7 @@ public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -133,48 +142,57 @@ public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -185,12 +203,12 @@ public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -198,28 +216,20 @@ public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapLongKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapLongKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapLongKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapLongKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -234,24 +244,24 @@ public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -261,19 +271,17 @@ public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapObjectKey.java
index 054b2e3..80eda7f 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapObjectKey.java
@@ -19,104 +19,112 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHeap {
-  public VMStatsLRURegionEntryHeapObjectKey(RegionEntryContext context, Object key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapObjectKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapObjectKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapObjectKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapObjectKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapObjectKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapObjectKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final Object key;
+
+  public VMStatsLRURegionEntryHeapObjectKey(final RegionEntryContext context, final Object key,
+      final Object value) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     this.key = key;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapObjectKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapObjectKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -124,6 +132,7 @@ public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHea
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -133,48 +142,57 @@ public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHea
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -185,12 +203,12 @@ public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHea
     return getKey();
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -198,28 +216,20 @@ public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHea
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapObjectKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapObjectKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapObjectKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapObjectKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -234,24 +244,24 @@ public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHea
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -261,10 +271,8 @@ public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHea
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final Object key;
-
   @Override
   public Object getKey() {
     return this.key;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapStringKey1.java
index 3185c06..9df1073 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapStringKey1.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapStringKey1.java
@@ -19,122 +19,129 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHeap {
-  public VMStatsLRURegionEntryHeapStringKey1(RegionEntryContext context, String key, Object value,
-      boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapStringKey1> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey1.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapStringKey1> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey1.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapStringKey1> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey1.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long bits1;
+
+  public VMStatsLRURegionEntryHeapStringKey1(final RegionEntryContext context, final String key,
+      final Object value, final boolean byteEncode) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
+    long tempBits1 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
-        tmpBits1 |= (byte) key.charAt(i) & 0xff;
-        tmpBits1 <<= 8;
+        tempBits1 |= (byte) key.charAt(i) & 0xff;
+        tempBits1 <<= 8;
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
-        tmpBits1 |= key.charAt(i);
-        tmpBits1 <<= 16;
+        tempBits1 |= key.charAt(i);
+        tempBits1 <<= 16;
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapStringKey1> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey1.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -142,6 +149,7 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -151,48 +159,57 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -203,12 +220,12 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -216,28 +233,20 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapStringKey1> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey1.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapStringKey1> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey1.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -252,24 +261,24 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -279,10 +288,8 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long bits1;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -295,18 +302,18 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 8;
-        chars[i] = (char) (tmpBits1 & 0x00ff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 8;
+        chars[i] = (char) (tempBits1 & 0x00ff);
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
       }
     }
     return new String(chars);
@@ -314,25 +321,25 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 8;
-            char c = (char) (tmpBits1 & 0x00ff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 8;
+            char character = (char) (tempBits1 & 0x00ff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 16;
-            char c = (char) (tmpBits1 & 0x00FFff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 16;
+            char character = (char) (tempBits1 & 0x00FFff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapStringKey2.java
index 1df514f..dc0b9d2 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapStringKey2.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapStringKey2.java
@@ -19,134 +19,150 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHeap {
-  public VMStatsLRURegionEntryHeapStringKey2(RegionEntryContext context, String key, Object value,
-      boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapStringKey2> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey2.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapStringKey2> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey2.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapStringKey2> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey2.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  /**
+   * strlen is encoded in lowest 6 bits (max strlen is 63)<br>
+   * character encoding info is in bits 7 and 8<br>
+   * The other bits are used to encoded character data.
+   */
+  private final long bits1;
+  /**
+   * bits2 encodes character data
+   */
+  private final long bits2;
+
+  public VMStatsLRURegionEntryHeapStringKey2(final RegionEntryContext context, final String key,
+      final Object value, final boolean byteEncode) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    long tmpBits2 = 0L;
+    long tempBits1 = 0L;
+    long tempBits2 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
         if (i < 7) {
-          tmpBits1 |= (byte) key.charAt(i) & 0xff;
-          tmpBits1 <<= 8;
+          tempBits1 |= (byte) key.charAt(i) & 0xff;
+          tempBits1 <<= 8;
         } else {
-          tmpBits2 <<= 8;
-          tmpBits2 |= (byte) key.charAt(i) & 0xff;
+          tempBits2 <<= 8;
+          tempBits2 |= (byte) key.charAt(i) & 0xff;
         }
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
         if (i < 3) {
-          tmpBits1 |= key.charAt(i);
-          tmpBits1 <<= 16;
+          tempBits1 |= key.charAt(i);
+          tempBits1 <<= 16;
         } else {
-          tmpBits2 <<= 16;
-          tmpBits2 |= key.charAt(i);
+          tempBits2 <<= 16;
+          tempBits2 |= key.charAt(i);
         }
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-    this.bits2 = tmpBits2;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+    this.bits2 = tempBits2;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapStringKey2> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey2.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -154,6 +170,7 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -163,48 +180,57 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -215,12 +241,12 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -228,28 +254,20 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapStringKey2> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey2.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapStringKey2> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey2.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -264,24 +282,24 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -291,15 +309,8 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  // strlen is encoded in lowest 6 bits (max strlen is 63)
-  // character encoding info is in bits 7 and 8
-  // The other bits are used to encoded character data.
-  private final long bits1;
-  // bits2 encodes character data
-  private final long bits2;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -312,28 +323,28 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
-    long tmpBits2 = this.bits2;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+    long tempBits2 = this.bits2;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 7) {
-          tmpBits1 >>= 8;
-          chars[i] = (char) (tmpBits1 & 0x00ff);
+          tempBits1 >>= 8;
+          chars[i] = (char) (tempBits1 & 0x00ff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00ff);
-          tmpBits2 >>= 8;
+          chars[i] = (char) (tempBits2 & 0x00ff);
+          tempBits2 >>= 8;
         }
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 3) {
-          tmpBits1 >>= 16;
-          chars[i] = (char) (tmpBits1 & 0x00FFff);
+          tempBits1 >>= 16;
+          chars[i] = (char) (tempBits1 & 0x00FFff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00FFff);
-          tmpBits2 >>= 16;
+          chars[i] = (char) (tempBits2 & 0x00FFff);
+          tempBits2 >>= 16;
         }
       }
     }
@@ -342,38 +353,38 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
-        long tmpBits2 = this.bits2;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+        long tempBits2 = this.bits2;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 7) {
-              tmpBits1 >>= 8;
-              c = (char) (tmpBits1 & 0x00ff);
+              tempBits1 >>= 8;
+              character = (char) (tempBits1 & 0x00ff);
             } else {
-              c = (char) (tmpBits2 & 0x00ff);
-              tmpBits2 >>= 8;
+              character = (char) (tempBits2 & 0x00ff);
+              tempBits2 >>= 8;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 3) {
-              tmpBits1 >>= 16;
-              c = (char) (tmpBits1 & 0x00FFff);
+              tempBits1 >>= 16;
+              character = (char) (tempBits1 & 0x00FFff);
             } else {
-              c = (char) (tmpBits2 & 0x00FFff);
-              tmpBits2 >>= 16;
+              character = (char) (tempBits2 & 0x00FFff);
+              tempBits2 >>= 16;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapUUIDKey.java
index c389078..3191b4c 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapUUIDKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryHeapUUIDKey.java
@@ -20,31 +20,51 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap {
-  public VMStatsLRURegionEntryHeapUUIDKey(RegionEntryContext context, UUID key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapUUIDKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapUUIDKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapUUIDKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapUUIDKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapUUIDKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapUUIDKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long keyMostSigBits;
+  private final long keyLeastSigBits;
+
+  public VMStatsLRURegionEntryHeapUUIDKey(final RegionEntryContext context, final UUID key,
+      final Object value) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     this.keyMostSigBits = key.getMostSignificantBits();
@@ -52,73 +72,62 @@ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryHeapUUIDKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapUUIDKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -126,6 +135,7 @@ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -135,48 +145,57 @@ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -187,12 +206,12 @@ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -200,28 +219,20 @@ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapUUIDKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapUUIDKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryHeapUUIDKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapUUIDKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -236,24 +247,24 @@ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -263,20 +274,17 @@ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long keyMostSigBits;
-  private final long keyLeastSigBits;
-
   @Override
   public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof UUID) {
-      UUID uuid = (UUID) k;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof UUID) {
+      UUID uuid = (UUID) key;
       return uuid.getLeastSignificantBits() == this.keyLeastSigBits
           && uuid.getMostSignificantBits() == this.keyMostSigBits;
     }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapIntKey.java
index 024bc5a..4792fc4 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapIntKey.java
@@ -19,8 +19,9 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -30,57 +31,68 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOffHeap {
-  public VMStatsLRURegionEntryOffHeapIntKey(RegionEntryContext context, int key,
-      @Retained Object value) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapIntKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapIntKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapIntKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapIntKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapIntKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapIntKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final int key;
+
+  public VMStatsLRURegionEntryOffHeapIntKey(final RegionEntryContext context, final int key,
+      @Retained final Object value) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    this.key = key;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -94,24 +106,24 @@ public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOff
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -122,57 +134,55 @@ public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOff
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -180,6 +190,7 @@ public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOff
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -189,48 +200,57 @@ public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOff
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -241,12 +261,12 @@ public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOff
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -254,28 +274,20 @@ public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOff
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapIntKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapIntKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -290,24 +302,24 @@ public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOff
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -317,19 +329,17 @@ public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOff
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final int key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapLongKey.java
index 2f6afb3..bb37c77 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapLongKey.java
@@ -19,8 +19,9 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -30,57 +31,69 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOffHeap {
-  public VMStatsLRURegionEntryOffHeapLongKey(RegionEntryContext context, long key,
-      @Retained Object value) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapLongKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapLongKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapLongKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapLongKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class,
+          "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapLongKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapLongKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long key;
+
+  public VMStatsLRURegionEntryOffHeapLongKey(final RegionEntryContext context, final long key,
+      @Retained final Object value) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    this.key = key;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -94,24 +107,24 @@ public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOf
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -122,57 +135,55 @@ public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOf
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -180,6 +191,7 @@ public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOf
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -189,48 +201,57 @@ public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOf
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -241,12 +262,12 @@ public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOf
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -254,28 +275,20 @@ public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOf
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapLongKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapLongKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -290,24 +303,24 @@ public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOf
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -317,19 +330,17 @@ public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOf
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapObjectKey.java
index 5a1f42e..2b7e313 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapObjectKey.java
@@ -19,8 +19,9 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -30,58 +31,71 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntryOffHeap {
-  public VMStatsLRURegionEntryOffHeapObjectKey(RegionEntryContext context, Object key,
-      @Retained Object value) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapObjectKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class,
+          "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapObjectKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class,
-          "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapObjectKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapObjectKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class,
+          "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapObjectKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapObjectKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final Object key;
 
+  public VMStatsLRURegionEntryOffHeapObjectKey(final RegionEntryContext context, final Object key,
+      @Retained final Object value) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    this.key = key;
+  }
+
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -95,24 +109,24 @@ public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntry
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -123,57 +137,55 @@ public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntry
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -181,6 +193,7 @@ public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntry
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -190,48 +203,57 @@ public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntry
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -242,12 +264,12 @@ public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntry
     return getKey();
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -255,29 +277,20 @@ public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntry
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapObjectKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapObjectKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -292,24 +305,24 @@ public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntry
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -319,10 +332,8 @@ public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntry
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final Object key;
-
   @Override
   public Object getKey() {
     return this.key;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapStringKey1.java
index 4990425..48954dc 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapStringKey1.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapStringKey1.java
@@ -19,8 +19,9 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -30,75 +31,89 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntryOffHeap {
-  public VMStatsLRURegionEntryOffHeapStringKey1(RegionEntryContext context, String key,
-      @Retained Object value, boolean byteEncode) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    if (byteEncode) {
-      for (int i = key.length() - 1; i >= 0; i--) {
-        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
-        // keep findbugs happy.
-        tmpBits1 |= (byte) key.charAt(i) & 0xff;
-        tmpBits1 <<= 8;
-      }
-      tmpBits1 |= 1 << 6;
-    } else {
-      for (int i = key.length() - 1; i >= 0; i--) {
-        tmpBits1 |= key.charAt(i);
-        tmpBits1 <<= 16;
-      }
-    }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey1> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey1.class,
+          "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey1> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey1.class,
-          "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey1> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey1.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey1> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey1.class,
+          "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey1> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey1.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey1> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey1.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long bits1;
 
+  public VMStatsLRURegionEntryOffHeapStringKey1(final RegionEntryContext context, final String key,
+      @Retained final Object value, final boolean byteEncode) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
+    long tempBits1 = 0L;
+    if (byteEncode) {
+      for (int i = key.length() - 1; i >= 0; i--) {
+        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
+        // keep findbugs happy.
+        tempBits1 |= (byte) key.charAt(i) & 0xff;
+        tempBits1 <<= 8;
+      }
+      tempBits1 |= 1 << 6;
+    } else {
+      for (int i = key.length() - 1; i >= 0; i--) {
+        tempBits1 |= key.charAt(i);
+        tempBits1 <<= 16;
+      }
+    }
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+  }
+
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -112,24 +127,24 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -140,57 +155,55 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -198,6 +211,7 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -207,48 +221,57 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -259,12 +282,12 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -272,30 +295,20 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey1> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey1.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey1> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey1.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -310,24 +323,24 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -337,10 +350,8 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long bits1;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -353,18 +364,18 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 8;
-        chars[i] = (char) (tmpBits1 & 0x00ff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 8;
+        chars[i] = (char) (tempBits1 & 0x00ff);
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
       }
     }
     return new String(chars);
@@ -372,25 +383,25 @@ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntr
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 8;
-            char c = (char) (tmpBits1 & 0x00ff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 8;
+            char character = (char) (tempBits1 & 0x00ff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 16;
-            char c = (char) (tmpBits1 & 0x00FFff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 16;
+            char character = (char) (tempBits1 & 0x00FFff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapStringKey2.java
index 8b94a01..55b2e90 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapStringKey2.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapStringKey2.java
@@ -19,8 +19,9 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -30,87 +31,110 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntryOffHeap {
-  public VMStatsLRURegionEntryOffHeapStringKey2(RegionEntryContext context, String key,
-      @Retained Object value, boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey2> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey2.class,
+          "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  // --------------------------------------- offheap fields ---------------------------------------
+  /**
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
+   */
+  @SuppressWarnings("unused")
+  @Retained
+  @Released
+  private volatile long offHeapAddress;
+  /**
+   * I needed to add this because I wanted clear to call setValue which normally can only be called
+   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
+   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
+   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
+   */
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey2> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey2.class,
+          "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey2> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey2.class,
+          "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey2> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey2.class,
+          "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  /**
+   * strlen is encoded in lowest 6 bits (max strlen is 63)<br>
+   * character encoding info is in bits 7 and 8<br>
+   * The other bits are used to encoded character data.
+   */
+  private final long bits1;
+  /**
+   * bits2 encodes character data
+   */
+  private final long bits2;
+
+  public VMStatsLRURegionEntryOffHeapStringKey2(final RegionEntryContext context, final String key,
+      @Retained final Object value, final boolean byteEncode) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    long tmpBits2 = 0L;
+    long tempBits1 = 0L;
+    long tempBits2 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
         if (i < 7) {
-          tmpBits1 |= (byte) key.charAt(i) & 0xff;
-          tmpBits1 <<= 8;
+          tempBits1 |= (byte) key.charAt(i) & 0xff;
+          tempBits1 <<= 8;
         } else {
-          tmpBits2 <<= 8;
-          tmpBits2 |= (byte) key.charAt(i) & 0xff;
+          tempBits2 <<= 8;
+          tempBits2 |= (byte) key.charAt(i) & 0xff;
         }
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
         if (i < 3) {
-          tmpBits1 |= key.charAt(i);
-          tmpBits1 <<= 16;
+          tempBits1 |= key.charAt(i);
+          tempBits1 <<= 16;
         } else {
-          tmpBits2 <<= 16;
-          tmpBits2 |= key.charAt(i);
+          tempBits2 <<= 16;
+          tempBits2 |= key.charAt(i);
         }
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-    this.bits2 = tmpBits2;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+    this.bits2 = tempBits2;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey2> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey2.class,
-          "lastModified");
-  /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
-   */
-  @SuppressWarnings("unused")
-  @Retained
-  @Released
-  private volatile long ohAddress;
-  /**
-   * I needed to add this because I wanted clear to call setValue which normally can only be called
-   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
-   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
-   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
-   */
-  private final static AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey2> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey2.class, "ohAddress");
-
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -124,24 +148,24 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -152,57 +176,55 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -210,6 +232,7 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -219,48 +242,57 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -271,12 +303,12 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -284,30 +316,20 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey2> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey2.class,
-          "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapStringKey2> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapStringKey2.class,
-          "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -322,24 +344,24 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -349,15 +371,8 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  // strlen is encoded in lowest 6 bits (max strlen is 63)
-  // character encoding info is in bits 7 and 8
-  // The other bits are used to encoded character data.
-  private final long bits1;
-  // bits2 encodes character data
-  private final long bits2;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -370,28 +385,28 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
-    long tmpBits2 = this.bits2;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+    long tempBits2 = this.bits2;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 7) {
-          tmpBits1 >>= 8;
-          chars[i] = (char) (tmpBits1 & 0x00ff);
+          tempBits1 >>= 8;
+          chars[i] = (char) (tempBits1 & 0x00ff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00ff);
-          tmpBits2 >>= 8;
+          chars[i] = (char) (tempBits2 & 0x00ff);
+          tempBits2 >>= 8;
         }
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 3) {
-          tmpBits1 >>= 16;
-          chars[i] = (char) (tmpBits1 & 0x00FFff);
+          tempBits1 >>= 16;
+          chars[i] = (char) (tempBits1 & 0x00FFff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00FFff);
-          tmpBits2 >>= 16;
+          chars[i] = (char) (tempBits2 & 0x00FFff);
+          tempBits2 >>= 16;
         }
       }
     }
@@ -400,38 +415,38 @@ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntr
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
-        long tmpBits2 = this.bits2;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+        long tempBits2 = this.bits2;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 7) {
-              tmpBits1 >>= 8;
-              c = (char) (tmpBits1 & 0x00ff);
+              tempBits1 >>= 8;
+              character = (char) (tempBits1 & 0x00ff);
             } else {
-              c = (char) (tmpBits2 & 0x00ff);
-              tmpBits2 >>= 8;
+              character = (char) (tempBits2 & 0x00ff);
+              tempBits2 >>= 8;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 3) {
-              tmpBits1 >>= 16;
-              c = (char) (tmpBits1 & 0x00FFff);
+              tempBits1 >>= 16;
+              character = (char) (tempBits1 & 0x00FFff);
             } else {
-              c = (char) (tmpBits2 & 0x00FFff);
-              tmpBits2 >>= 16;
+              character = (char) (tempBits2 & 0x00FFff);
+              tempBits2 >>= 16;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapUUIDKey.java
index c6dd20a..27923a5 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapUUIDKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsLRURegionEntryOffHeapUUIDKey.java
@@ -20,8 +20,9 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.cache.Token;
@@ -31,58 +32,71 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOffHeap {
-  public VMStatsLRURegionEntryOffHeapUUIDKey(RegionEntryContext context, UUID key,
-      @Retained Object value) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    this.keyMostSigBits = key.getMostSignificantBits();
-    this.keyLeastSigBits = key.getLeastSignificantBits();
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapUUIDKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapUUIDKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapUUIDKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapUUIDKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapUUIDKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapUUIDKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsLRURegionEntryOffHeapUUIDKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapUUIDKey.class,
+          "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapUUIDKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapUUIDKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapUUIDKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapUUIDKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long keyMostSigBits;
+  private final long keyLeastSigBits;
 
+  public VMStatsLRURegionEntryOffHeapUUIDKey(final RegionEntryContext context, final UUID key,
+      @Retained final Object value) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    this.keyMostSigBits = key.getMostSignificantBits();
+    this.keyLeastSigBits = key.getLeastSignificantBits();
+  }
+
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -96,24 +110,24 @@ public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOf
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -124,57 +138,55 @@ public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOf
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
     // nothing needed for LRUs with no disk
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -182,6 +194,7 @@ public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOf
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -191,48 +204,57 @@ public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOf
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -243,12 +265,12 @@ public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOf
     return null;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -256,28 +278,20 @@ public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOf
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapUUIDKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapUUIDKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsLRURegionEntryOffHeapUUIDKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapUUIDKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -292,24 +306,24 @@ public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOf
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -319,20 +333,17 @@ public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOf
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long keyMostSigBits;
-  private final long keyLeastSigBits;
-
   @Override
   public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof UUID) {
-      UUID uuid = (UUID) k;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof UUID) {
+      UUID uuid = (UUID) key;
       return uuid.getLeastSignificantBits() == this.keyLeastSigBits
           && uuid.getMostSignificantBits() == this.keyMostSigBits;
     }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapIntKey.java
index c9df2d7..6b4d3a9 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapIntKey.java
@@ -21,89 +21,95 @@ import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryHeapIntKey extends VMStatsRegionEntryHeap {
-  public VMStatsRegionEntryHeapIntKey(RegionEntryContext context, int key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapIntKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapIntKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapIntKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapIntKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapIntKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapIntKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final int key;
+
+  public VMStatsRegionEntryHeapIntKey(final RegionEntryContext context, final int key,
+      final Object value) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     this.key = key;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapIntKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapIntKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -111,28 +117,20 @@ public class VMStatsRegionEntryHeapIntKey extends VMStatsRegionEntryHeap {
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapIntKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapIntKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapIntKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapIntKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -147,24 +145,24 @@ public class VMStatsRegionEntryHeapIntKey extends VMStatsRegionEntryHeap {
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -174,19 +172,17 @@ public class VMStatsRegionEntryHeapIntKey extends VMStatsRegionEntryHeap {
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final int key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapLongKey.java
index 32c2d84..4ed1c42 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapLongKey.java
@@ -21,89 +21,95 @@ import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryHeapLongKey extends VMStatsRegionEntryHeap {
-  public VMStatsRegionEntryHeapLongKey(RegionEntryContext context, long key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapLongKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapLongKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapLongKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapLongKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapLongKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapLongKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long key;
+
+  public VMStatsRegionEntryHeapLongKey(final RegionEntryContext context, final long key,
+      final Object value) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     this.key = key;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapLongKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapLongKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -111,28 +117,20 @@ public class VMStatsRegionEntryHeapLongKey extends VMStatsRegionEntryHeap {
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapLongKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapLongKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapLongKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapLongKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -147,24 +145,24 @@ public class VMStatsRegionEntryHeapLongKey extends VMStatsRegionEntryHeap {
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -174,19 +172,17 @@ public class VMStatsRegionEntryHeapLongKey extends VMStatsRegionEntryHeap {
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapObjectKey.java
index 154c549..087ef62 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapObjectKey.java
@@ -21,89 +21,95 @@ import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryHeapObjectKey extends VMStatsRegionEntryHeap {
-  public VMStatsRegionEntryHeapObjectKey(RegionEntryContext context, Object key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapObjectKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapObjectKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapObjectKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapObjectKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapObjectKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapObjectKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final Object key;
+
+  public VMStatsRegionEntryHeapObjectKey(final RegionEntryContext context, final Object key,
+      final Object value) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     this.key = key;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapObjectKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapObjectKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -111,28 +117,20 @@ public class VMStatsRegionEntryHeapObjectKey extends VMStatsRegionEntryHeap {
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapObjectKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapObjectKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapObjectKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapObjectKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -147,24 +145,24 @@ public class VMStatsRegionEntryHeapObjectKey extends VMStatsRegionEntryHeap {
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -174,10 +172,8 @@ public class VMStatsRegionEntryHeapObjectKey extends VMStatsRegionEntryHeap {
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final Object key;
-
   @Override
   public Object getKey() {
     return this.key;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapStringKey1.java
index 29c1044..12697e7 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapStringKey1.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapStringKey1.java
@@ -21,107 +21,112 @@ import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryHeapStringKey1 extends VMStatsRegionEntryHeap {
-  public VMStatsRegionEntryHeapStringKey1(RegionEntryContext context, String key, Object value,
-      boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapStringKey1> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey1.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapStringKey1> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey1.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapStringKey1> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey1.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long bits1;
+
+  public VMStatsRegionEntryHeapStringKey1(final RegionEntryContext context, final String key,
+      final Object value, final boolean byteEncode) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
+    long tempBits1 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
-        tmpBits1 |= (byte) key.charAt(i) & 0xff;
-        tmpBits1 <<= 8;
+        tempBits1 |= (byte) key.charAt(i) & 0xff;
+        tempBits1 <<= 8;
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
-        tmpBits1 |= key.charAt(i);
-        tmpBits1 <<= 16;
+        tempBits1 |= key.charAt(i);
+        tempBits1 <<= 16;
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapStringKey1> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey1.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -129,28 +134,20 @@ public class VMStatsRegionEntryHeapStringKey1 extends VMStatsRegionEntryHeap {
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapStringKey1> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey1.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapStringKey1> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey1.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -165,24 +162,24 @@ public class VMStatsRegionEntryHeapStringKey1 extends VMStatsRegionEntryHeap {
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -192,10 +189,8 @@ public class VMStatsRegionEntryHeapStringKey1 extends VMStatsRegionEntryHeap {
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long bits1;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -208,18 +203,18 @@ public class VMStatsRegionEntryHeapStringKey1 extends VMStatsRegionEntryHeap {
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 8;
-        chars[i] = (char) (tmpBits1 & 0x00ff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 8;
+        chars[i] = (char) (tempBits1 & 0x00ff);
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
       }
     }
     return new String(chars);
@@ -227,25 +222,25 @@ public class VMStatsRegionEntryHeapStringKey1 extends VMStatsRegionEntryHeap {
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 8;
-            char c = (char) (tmpBits1 & 0x00ff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 8;
+            char character = (char) (tempBits1 & 0x00ff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 16;
-            char c = (char) (tmpBits1 & 0x00FFff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 16;
+            char character = (char) (tempBits1 & 0x00FFff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapStringKey2.java
index 212b35b..81cc3f0 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapStringKey2.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapStringKey2.java
@@ -21,119 +21,133 @@ import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryHeapStringKey2 extends VMStatsRegionEntryHeap {
-  public VMStatsRegionEntryHeapStringKey2(RegionEntryContext context, String key, Object value,
-      boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapStringKey2> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey2.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapStringKey2> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey2.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapStringKey2> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey2.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  /**
+   * strlen is encoded in lowest 6 bits (max strlen is 63)<br>
+   * character encoding info is in bits 7 and 8<br>
+   * The other bits are used to encoded character data.
+   */
+  private final long bits1;
+  /**
+   * bits2 encodes character data
+   */
+  private final long bits2;
+
+  public VMStatsRegionEntryHeapStringKey2(final RegionEntryContext context, final String key,
+      final Object value, final boolean byteEncode) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    long tmpBits2 = 0L;
+    long tempBits1 = 0L;
+    long tempBits2 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
         if (i < 7) {
-          tmpBits1 |= (byte) key.charAt(i) & 0xff;
-          tmpBits1 <<= 8;
+          tempBits1 |= (byte) key.charAt(i) & 0xff;
+          tempBits1 <<= 8;
         } else {
-          tmpBits2 <<= 8;
-          tmpBits2 |= (byte) key.charAt(i) & 0xff;
+          tempBits2 <<= 8;
+          tempBits2 |= (byte) key.charAt(i) & 0xff;
         }
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
         if (i < 3) {
-          tmpBits1 |= key.charAt(i);
-          tmpBits1 <<= 16;
+          tempBits1 |= key.charAt(i);
+          tempBits1 <<= 16;
         } else {
-          tmpBits2 <<= 16;
-          tmpBits2 |= key.charAt(i);
+          tempBits2 <<= 16;
+          tempBits2 |= key.charAt(i);
         }
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-    this.bits2 = tmpBits2;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+    this.bits2 = tempBits2;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapStringKey2> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey2.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -141,28 +155,20 @@ public class VMStatsRegionEntryHeapStringKey2 extends VMStatsRegionEntryHeap {
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapStringKey2> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey2.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapStringKey2> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapStringKey2.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -177,24 +183,24 @@ public class VMStatsRegionEntryHeapStringKey2 extends VMStatsRegionEntryHeap {
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -204,15 +210,8 @@ public class VMStatsRegionEntryHeapStringKey2 extends VMStatsRegionEntryHeap {
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  // strlen is encoded in lowest 6 bits (max strlen is 63)
-  // character encoding info is in bits 7 and 8
-  // The other bits are used to encoded character data.
-  private final long bits1;
-  // bits2 encodes character data
-  private final long bits2;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -225,28 +224,28 @@ public class VMStatsRegionEntryHeapStringKey2 extends VMStatsRegionEntryHeap {
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
-    long tmpBits2 = this.bits2;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+    long tempBits2 = this.bits2;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 7) {
-          tmpBits1 >>= 8;
-          chars[i] = (char) (tmpBits1 & 0x00ff);
+          tempBits1 >>= 8;
+          chars[i] = (char) (tempBits1 & 0x00ff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00ff);
-          tmpBits2 >>= 8;
+          chars[i] = (char) (tempBits2 & 0x00ff);
+          tempBits2 >>= 8;
         }
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 3) {
-          tmpBits1 >>= 16;
-          chars[i] = (char) (tmpBits1 & 0x00FFff);
+          tempBits1 >>= 16;
+          chars[i] = (char) (tempBits1 & 0x00FFff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00FFff);
-          tmpBits2 >>= 16;
+          chars[i] = (char) (tempBits2 & 0x00FFff);
+          tempBits2 >>= 16;
         }
       }
     }
@@ -255,38 +254,38 @@ public class VMStatsRegionEntryHeapStringKey2 extends VMStatsRegionEntryHeap {
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
-        long tmpBits2 = this.bits2;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+        long tempBits2 = this.bits2;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 7) {
-              tmpBits1 >>= 8;
-              c = (char) (tmpBits1 & 0x00ff);
+              tempBits1 >>= 8;
+              character = (char) (tempBits1 & 0x00ff);
             } else {
-              c = (char) (tmpBits2 & 0x00ff);
-              tmpBits2 >>= 8;
+              character = (char) (tempBits2 & 0x00ff);
+              tempBits2 >>= 8;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 3) {
-              tmpBits1 >>= 16;
-              c = (char) (tmpBits1 & 0x00FFff);
+              tempBits1 >>= 16;
+              character = (char) (tempBits1 & 0x00FFff);
             } else {
-              c = (char) (tmpBits2 & 0x00FFff);
-              tmpBits2 >>= 16;
+              character = (char) (tempBits2 & 0x00FFff);
+              tempBits2 >>= 16;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapUUIDKey.java
index e81fe77..7fffbac 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapUUIDKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryHeapUUIDKey.java
@@ -22,25 +22,44 @@ import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.InternalStatisticsDisabledException;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryHeapUUIDKey extends VMStatsRegionEntryHeap {
-  public VMStatsRegionEntryHeapUUIDKey(RegionEntryContext context, UUID key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapUUIDKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapUUIDKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapUUIDKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapUUIDKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapUUIDKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapUUIDKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long keyMostSigBits;
+  private final long keyLeastSigBits;
+
+  public VMStatsRegionEntryHeapUUIDKey(final RegionEntryContext context, final UUID key,
+      final Object value) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     this.keyMostSigBits = key.getMostSignificantBits();
@@ -48,64 +67,52 @@ public class VMStatsRegionEntryHeapUUIDKey extends VMStatsRegionEntryHeap {
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryHeapUUIDKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryHeapUUIDKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -113,28 +120,20 @@ public class VMStatsRegionEntryHeapUUIDKey extends VMStatsRegionEntryHeap {
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapUUIDKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapUUIDKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryHeapUUIDKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryHeapUUIDKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -149,24 +148,24 @@ public class VMStatsRegionEntryHeapUUIDKey extends VMStatsRegionEntryHeap {
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -176,20 +175,17 @@ public class VMStatsRegionEntryHeapUUIDKey extends VMStatsRegionEntryHeap {
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long keyMostSigBits;
-  private final long keyLeastSigBits;
-
   @Override
   public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof UUID) {
-      UUID uuid = (UUID) k;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof UUID) {
+      UUID uuid = (UUID) key;
       return uuid.getLeastSignificantBits() == this.keyLeastSigBits
           && uuid.getMostSignificantBits() == this.keyMostSigBits;
     }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapIntKey.java
index 02d9d1f..197a80a 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapIntKey.java
@@ -26,57 +26,68 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryOffHeapIntKey extends VMStatsRegionEntryOffHeap {
-  public VMStatsRegionEntryOffHeapIntKey(RegionEntryContext context, int key,
-      @Retained Object value) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapIntKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapIntKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapIntKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapIntKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapIntKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapIntKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapIntKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapIntKey.class, "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapIntKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapIntKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapIntKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapIntKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final int key;
+
+  public VMStatsRegionEntryOffHeapIntKey(final RegionEntryContext context, final int key,
+      @Retained final Object value) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    this.key = key;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -90,24 +101,24 @@ public class VMStatsRegionEntryOffHeapIntKey extends VMStatsRegionEntryOffHeap {
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -118,48 +129,45 @@ public class VMStatsRegionEntryOffHeapIntKey extends VMStatsRegionEntryOffHeap {
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -167,28 +175,20 @@ public class VMStatsRegionEntryOffHeapIntKey extends VMStatsRegionEntryOffHeap {
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapIntKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapIntKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapIntKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapIntKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -203,24 +203,24 @@ public class VMStatsRegionEntryOffHeapIntKey extends VMStatsRegionEntryOffHeap {
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -230,19 +230,17 @@ public class VMStatsRegionEntryOffHeapIntKey extends VMStatsRegionEntryOffHeap {
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final int key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapLongKey.java
index 3ab9c1f..bde45fa 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapLongKey.java
@@ -26,57 +26,68 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryOffHeapLongKey extends VMStatsRegionEntryOffHeap {
-  public VMStatsRegionEntryOffHeapLongKey(RegionEntryContext context, long key,
-      @Retained Object value) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapLongKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapLongKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapLongKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapLongKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapLongKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapLongKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapLongKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapLongKey.class, "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapLongKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapLongKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapLongKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapLongKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long key;
+
+  public VMStatsRegionEntryOffHeapLongKey(final RegionEntryContext context, final long key,
+      @Retained final Object value) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    this.key = key;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -90,24 +101,24 @@ public class VMStatsRegionEntryOffHeapLongKey extends VMStatsRegionEntryOffHeap
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -118,48 +129,45 @@ public class VMStatsRegionEntryOffHeapLongKey extends VMStatsRegionEntryOffHeap
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -167,28 +175,20 @@ public class VMStatsRegionEntryOffHeapLongKey extends VMStatsRegionEntryOffHeap
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapLongKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapLongKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapLongKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapLongKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -203,24 +203,24 @@ public class VMStatsRegionEntryOffHeapLongKey extends VMStatsRegionEntryOffHeap
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -230,19 +230,17 @@ public class VMStatsRegionEntryOffHeapLongKey extends VMStatsRegionEntryOffHeap
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapObjectKey.java
index e0c2f93..2a812a9 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapObjectKey.java
@@ -26,57 +26,68 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryOffHeapObjectKey extends VMStatsRegionEntryOffHeap {
-  public VMStatsRegionEntryOffHeapObjectKey(RegionEntryContext context, Object key,
-      @Retained Object value) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    this.key = key;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapObjectKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapObjectKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapObjectKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapObjectKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapObjectKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapObjectKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapObjectKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapObjectKey.class, "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapObjectKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapObjectKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapObjectKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapObjectKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final Object key;
+
+  public VMStatsRegionEntryOffHeapObjectKey(final RegionEntryContext context, final Object key,
+      @Retained final Object value) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    this.key = key;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -90,24 +101,24 @@ public class VMStatsRegionEntryOffHeapObjectKey extends VMStatsRegionEntryOffHea
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -118,48 +129,45 @@ public class VMStatsRegionEntryOffHeapObjectKey extends VMStatsRegionEntryOffHea
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -167,28 +175,20 @@ public class VMStatsRegionEntryOffHeapObjectKey extends VMStatsRegionEntryOffHea
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapObjectKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapObjectKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapObjectKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapObjectKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -203,24 +203,24 @@ public class VMStatsRegionEntryOffHeapObjectKey extends VMStatsRegionEntryOffHea
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -230,10 +230,8 @@ public class VMStatsRegionEntryOffHeapObjectKey extends VMStatsRegionEntryOffHea
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final Object key;
-
   @Override
   public Object getKey() {
     return this.key;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapStringKey1.java
index 46f1093..d05f166 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapStringKey1.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapStringKey1.java
@@ -26,74 +26,86 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryOffHeapStringKey1 extends VMStatsRegionEntryOffHeap {
-  public VMStatsRegionEntryOffHeapStringKey1(RegionEntryContext context, String key,
-      @Retained Object value, boolean byteEncode) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    if (byteEncode) {
-      for (int i = key.length() - 1; i >= 0; i--) {
-        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
-        // keep findbugs happy.
-        tmpBits1 |= (byte) key.charAt(i) & 0xff;
-        tmpBits1 <<= 8;
-      }
-      tmpBits1 |= 1 << 6;
-    } else {
-      for (int i = key.length() - 1; i >= 0; i--) {
-        tmpBits1 |= key.charAt(i);
-        tmpBits1 <<= 16;
-      }
-    }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapStringKey1> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapStringKey1> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapStringKey1> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapStringKey1> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.class,
+          "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapStringKey1> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapStringKey1> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long bits1;
+
+  public VMStatsRegionEntryOffHeapStringKey1(final RegionEntryContext context, final String key,
+      @Retained final Object value, final boolean byteEncode) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
+    long tempBits1 = 0L;
+    if (byteEncode) {
+      for (int i = key.length() - 1; i >= 0; i--) {
+        // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
+        // keep findbugs happy.
+        tempBits1 |= (byte) key.charAt(i) & 0xff;
+        tempBits1 <<= 8;
+      }
+      tempBits1 |= 1 << 6;
+    } else {
+      for (int i = key.length() - 1; i >= 0; i--) {
+        tempBits1 |= key.charAt(i);
+        tempBits1 <<= 16;
+      }
+    }
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -107,24 +119,24 @@ public class VMStatsRegionEntryOffHeapStringKey1 extends VMStatsRegionEntryOffHe
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -135,48 +147,45 @@ public class VMStatsRegionEntryOffHeapStringKey1 extends VMStatsRegionEntryOffHe
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -184,28 +193,20 @@ public class VMStatsRegionEntryOffHeapStringKey1 extends VMStatsRegionEntryOffHe
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapStringKey1> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapStringKey1> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -220,24 +221,24 @@ public class VMStatsRegionEntryOffHeapStringKey1 extends VMStatsRegionEntryOffHe
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -247,10 +248,8 @@ public class VMStatsRegionEntryOffHeapStringKey1 extends VMStatsRegionEntryOffHe
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long bits1;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -263,18 +262,18 @@ public class VMStatsRegionEntryOffHeapStringKey1 extends VMStatsRegionEntryOffHe
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 8;
-        chars[i] = (char) (tmpBits1 & 0x00ff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 8;
+        chars[i] = (char) (tempBits1 & 0x00ff);
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
-        tmpBits1 >>= 16;
-        chars[i] = (char) (tmpBits1 & 0x00FFff);
+      for (int i = 0; i < keyLength; i++) {
+        tempBits1 >>= 16;
+        chars[i] = (char) (tempBits1 & 0x00FFff);
       }
     }
     return new String(chars);
@@ -282,25 +281,25 @@ public class VMStatsRegionEntryOffHeapStringKey1 extends VMStatsRegionEntryOffHe
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 8;
-            char c = (char) (tmpBits1 & 0x00ff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 8;
+            char character = (char) (tempBits1 & 0x00ff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            tmpBits1 >>= 16;
-            char c = (char) (tmpBits1 & 0x00FFff);
-            if (str.charAt(i) != c) {
+          for (int i = 0; i < keyLength; i++) {
+            tempBits1 >>= 16;
+            char character = (char) (tempBits1 & 0x00FFff);
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapStringKey2.java
index da17d00..0ab255e 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapStringKey2.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapStringKey2.java
@@ -26,86 +26,107 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryOffHeapStringKey2 extends VMStatsRegionEntryOffHeap {
-  public VMStatsRegionEntryOffHeapStringKey2(RegionEntryContext context, String key,
-      @Retained Object value, boolean byteEncode) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapStringKey2> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey2.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  // --------------------------------------- offheap fields ---------------------------------------
+  /**
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
+   */
+  @SuppressWarnings("unused")
+  @Retained
+  @Released
+  private volatile long offHeapAddress;
+  /**
+   * I needed to add this because I wanted clear to call setValue which normally can only be called
+   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
+   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
+   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
+   */
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapStringKey2> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey2.class,
+          "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapStringKey2> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey2.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapStringKey2> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey2.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  /**
+   * strlen is encoded in lowest 6 bits (max strlen is 63)<br>
+   * character encoding info is in bits 7 and 8<br>
+   * The other bits are used to encoded character data.
+   */
+  private final long bits1;
+  /**
+   * bits2 encodes character data
+   */
+  private final long bits2;
+
+  public VMStatsRegionEntryOffHeapStringKey2(final RegionEntryContext context, final String key,
+      @Retained final Object value, final boolean byteEncode) {
     super(context, value);
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY
-    long tmpBits1 = 0L;
-    long tmpBits2 = 0L;
+    long tempBits1 = 0L;
+    long tempBits2 = 0L;
     if (byteEncode) {
       for (int i = key.length() - 1; i >= 0; i--) {
         // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to
         // keep findbugs happy.
         if (i < 7) {
-          tmpBits1 |= (byte) key.charAt(i) & 0xff;
-          tmpBits1 <<= 8;
+          tempBits1 |= (byte) key.charAt(i) & 0xff;
+          tempBits1 <<= 8;
         } else {
-          tmpBits2 <<= 8;
-          tmpBits2 |= (byte) key.charAt(i) & 0xff;
+          tempBits2 <<= 8;
+          tempBits2 |= (byte) key.charAt(i) & 0xff;
         }
       }
-      tmpBits1 |= 1 << 6;
+      tempBits1 |= 1 << 6;
     } else {
       for (int i = key.length() - 1; i >= 0; i--) {
         if (i < 3) {
-          tmpBits1 |= key.charAt(i);
-          tmpBits1 <<= 16;
+          tempBits1 |= key.charAt(i);
+          tempBits1 <<= 16;
         } else {
-          tmpBits2 <<= 16;
-          tmpBits2 |= key.charAt(i);
+          tempBits2 <<= 16;
+          tempBits2 |= key.charAt(i);
         }
       }
     }
-    tmpBits1 |= key.length();
-    this.bits1 = tmpBits1;
-    this.bits2 = tmpBits2;
+    tempBits1 |= key.length();
+    this.bits1 = tempBits1;
+    this.bits2 = tempBits2;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapStringKey2> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey2.class, "lastModified");
-  /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
-   */
-  @SuppressWarnings("unused")
-  @Retained
-  @Released
-  private volatile long ohAddress;
-  /**
-   * I needed to add this because I wanted clear to call setValue which normally can only be called
-   * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
-   * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
-   * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
-   */
-  private final static AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapStringKey2> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey2.class, "ohAddress");
-
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -119,24 +140,24 @@ public class VMStatsRegionEntryOffHeapStringKey2 extends VMStatsRegionEntryOffHe
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -147,48 +168,45 @@ public class VMStatsRegionEntryOffHeapStringKey2 extends VMStatsRegionEntryOffHe
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -196,28 +214,20 @@ public class VMStatsRegionEntryOffHeapStringKey2 extends VMStatsRegionEntryOffHe
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapStringKey2> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey2.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapStringKey2> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey2.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -232,24 +242,24 @@ public class VMStatsRegionEntryOffHeapStringKey2 extends VMStatsRegionEntryOffHe
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -259,15 +269,8 @@ public class VMStatsRegionEntryOffHeapStringKey2 extends VMStatsRegionEntryOffHe
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  // strlen is encoded in lowest 6 bits (max strlen is 63)
-  // character encoding info is in bits 7 and 8
-  // The other bits are used to encoded character data.
-  private final long bits1;
-  // bits2 encodes character data
-  private final long bits2;
-
   private int getKeyLength() {
     return (int) (this.bits1 & 0x003fL);
   }
@@ -280,28 +283,28 @@ public class VMStatsRegionEntryOffHeapStringKey2 extends VMStatsRegionEntryOffHe
 
   @Override
   public Object getKey() {
-    int keylen = getKeyLength();
-    char[] chars = new char[keylen];
-    long tmpBits1 = this.bits1;
-    long tmpBits2 = this.bits2;
+    int keyLength = getKeyLength();
+    char[] chars = new char[keyLength];
+    long tempBits1 = this.bits1;
+    long tempBits2 = this.bits2;
     if (getEncoding() == 1) {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 7) {
-          tmpBits1 >>= 8;
-          chars[i] = (char) (tmpBits1 & 0x00ff);
+          tempBits1 >>= 8;
+          chars[i] = (char) (tempBits1 & 0x00ff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00ff);
-          tmpBits2 >>= 8;
+          chars[i] = (char) (tempBits2 & 0x00ff);
+          tempBits2 >>= 8;
         }
       }
     } else {
-      for (int i = 0; i < keylen; i++) {
+      for (int i = 0; i < keyLength; i++) {
         if (i < 3) {
-          tmpBits1 >>= 16;
-          chars[i] = (char) (tmpBits1 & 0x00FFff);
+          tempBits1 >>= 16;
+          chars[i] = (char) (tempBits1 & 0x00FFff);
         } else {
-          chars[i] = (char) (tmpBits2 & 0x00FFff);
-          tmpBits2 >>= 16;
+          chars[i] = (char) (tempBits2 & 0x00FFff);
+          tempBits2 >>= 16;
         }
       }
     }
@@ -310,38 +313,38 @@ public class VMStatsRegionEntryOffHeapStringKey2 extends VMStatsRegionEntryOffHe
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof String) {
-      String str = (String) k;
-      int keylen = getKeyLength();
-      if (str.length() == keylen) {
-        long tmpBits1 = this.bits1;
-        long tmpBits2 = this.bits2;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof String) {
+      String stringKey = (String) key;
+      int keyLength = getKeyLength();
+      if (stringKey.length() == keyLength) {
+        long tempBits1 = this.bits1;
+        long tempBits2 = this.bits2;
         if (getEncoding() == 1) {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 7) {
-              tmpBits1 >>= 8;
-              c = (char) (tmpBits1 & 0x00ff);
+              tempBits1 >>= 8;
+              character = (char) (tempBits1 & 0x00ff);
             } else {
-              c = (char) (tmpBits2 & 0x00ff);
-              tmpBits2 >>= 8;
+              character = (char) (tempBits2 & 0x00ff);
+              tempBits2 >>= 8;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
         } else {
-          for (int i = 0; i < keylen; i++) {
-            char c;
+          for (int i = 0; i < keyLength; i++) {
+            char character;
             if (i < 3) {
-              tmpBits1 >>= 16;
-              c = (char) (tmpBits1 & 0x00FFff);
+              tempBits1 >>= 16;
+              character = (char) (tempBits1 & 0x00FFff);
             } else {
-              c = (char) (tmpBits2 & 0x00FFff);
-              tmpBits2 >>= 16;
+              character = (char) (tempBits2 & 0x00FFff);
+              tempBits2 >>= 16;
             }
-            if (str.charAt(i) != c) {
+            if (stringKey.charAt(i) != character) {
               return false;
             }
           }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapUUIDKey.java
index b5f1a45..411bd91 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapUUIDKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMStatsRegionEntryOffHeapUUIDKey.java
@@ -27,58 +27,70 @@ import org.apache.geode.internal.offheap.annotations.Retained;
 import org.apache.geode.internal.offheap.annotations.Unretained;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMStatsRegionEntryOffHeapUUIDKey extends VMStatsRegionEntryOffHeap {
-  public VMStatsRegionEntryOffHeapUUIDKey(RegionEntryContext context, UUID key,
-      @Retained Object value) {
-    super(context, value);
-    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-    this.keyMostSigBits = key.getMostSignificantBits();
-    this.keyLeastSigBits = key.getLeastSignificantBits();
-  }
-
-  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapUUIDKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapUUIDKey.class, "lastModified");
   protected int hash;
-  private HashEntry<Object, Object> next;
+  private HashEntry<Object, Object> nextEntry;
   @SuppressWarnings("unused")
   private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapUUIDKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapUUIDKey.class, "lastModified");
+  // --------------------------------------- offheap fields ---------------------------------------
   /**
-   * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
+   * All access done using OFF_HEAP_ADDRESS_UPDATER so it is used even though the compiler can not
+   * tell it is.
    */
   @SuppressWarnings("unused")
   @Retained
   @Released
-  private volatile long ohAddress;
+  private volatile long offHeapAddress;
   /**
    * I needed to add this because I wanted clear to call setValue which normally can only be called
    * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the
    * disk regions because they also get a rw lock in clear. Some hardware platforms do not support
    * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the
-   * re and we will once again be deadlocked. I don't know if we support any of the hardware
-   * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions.
+   * RegionEntry and we will once again be deadlocked. I don't know if we support any of the
+   * hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk
+   * regions.
    */
-  private final static AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapUUIDKey> ohAddrUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapUUIDKey.class, "ohAddress");
+  private static final AtomicLongFieldUpdater<VMStatsRegionEntryOffHeapUUIDKey> OFF_HEAP_ADDRESS_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapUUIDKey.class, "offHeapAddress");
+  // --------------------------------------- stats fields -----------------------------------------
+  private volatile long lastAccessed;
+  private volatile int hitCount;
+  private volatile int missCount;
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapUUIDKey> HIT_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapUUIDKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapUUIDKey> MISS_COUNT_UPDATER =
+      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapUUIDKey.class, "missCount");
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long keyMostSigBits;
+  private final long keyLeastSigBits;
+
+  public VMStatsRegionEntryOffHeapUUIDKey(final RegionEntryContext context, final UUID key,
+      @Retained final Object value) {
+    super(context, value);
+    // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+    this.keyMostSigBits = key.getMostSignificantBits();
+    this.keyLeastSigBits = key.getLeastSignificantBits();
+  }
 
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   public Token getValueAsToken() {
     return OffHeapRegionEntryHelper.getValueAsToken(this);
@@ -92,24 +104,24 @@ public class VMStatsRegionEntryOffHeapUUIDKey extends VMStatsRegionEntryOffHeap
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
   @Unretained
-  protected void setValueField(@Unretained Object v) {
-    OffHeapRegionEntryHelper.setValue(this, v);
+  protected void setValueField(@Unretained final Object value) {
+    OffHeapRegionEntryHelper.setValue(this, value);
   }
 
   @Override
   @Retained
-  public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
+  public Object getValueRetain(final RegionEntryContext context, final boolean decompress) {
     return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context);
   }
 
   @Override
   public long getAddress() {
-    return ohAddrUpdater.get(this);
+    return OFF_HEAP_ADDRESS_UPDATER.get(this);
   }
 
   @Override
-  public boolean setAddress(long expectedAddr, long newAddr) {
-    return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr);
+  public boolean setAddress(final long expectedAddress, long newAddress) {
+    return OFF_HEAP_ADDRESS_UPDATER.compareAndSet(this, expectedAddress, newAddress);
   }
 
   @Override
@@ -120,48 +132,45 @@ public class VMStatsRegionEntryOffHeapUUIDKey extends VMStatsRegionEntryOffHeap
 
   @Override
   public void returnToPool() {
-    // Deadcoded for now; never was working
+    // never implemented
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ---------------------------------------- stats code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // stats code
   @Override
-  public void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(final boolean isHit, final long time) {
     setLastAccessed(time);
-    if (hit) {
+    if (isHit) {
       incrementHitCount();
     } else {
       incrementMissCount();
@@ -169,28 +178,20 @@ public class VMStatsRegionEntryOffHeapUUIDKey extends VMStatsRegionEntryOffHeap
   }
 
   @Override
-  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(final long lastModified, final long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
       setLastAccessed(lastAccessed);
     }
   }
 
-  private volatile long lastAccessed;
-  private volatile int hitCount;
-  private volatile int missCount;
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapUUIDKey> hitCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapUUIDKey.class, "hitCount");
-  private static final AtomicIntegerFieldUpdater<VMStatsRegionEntryOffHeapUUIDKey> missCountUpdater =
-      AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapUUIDKey.class, "missCount");
-
   @Override
   public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
 
   @Override
-  public void setLastAccessed(long lastAccessed) {
+  public void setLastAccessed(final long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
 
@@ -205,24 +206,24 @@ public class VMStatsRegionEntryOffHeapUUIDKey extends VMStatsRegionEntryOffHeap
   }
 
   private void incrementHitCount() {
-    hitCountUpdater.incrementAndGet(this);
+    HIT_COUNT_UPDATER.incrementAndGet(this);
   }
 
   private void incrementMissCount() {
-    missCountUpdater.incrementAndGet(this);
+    MISS_COUNT_UPDATER.incrementAndGet(this);
   }
 
   @Override
   public void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+    HIT_COUNT_UPDATER.set(this, 0);
+    MISS_COUNT_UPDATER.set(this, 0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   @Override
-  public void txDidDestroy(long currTime) {
-    setLastModified(currTime);
-    setLastAccessed(currTime);
+  public void txDidDestroy(long timeStamp) {
+    setLastModified(timeStamp);
+    setLastAccessed(timeStamp);
     this.hitCount = 0;
     this.missCount = 0;
   }
@@ -232,20 +233,17 @@ public class VMStatsRegionEntryOffHeapUUIDKey extends VMStatsRegionEntryOffHeap
     return true;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long keyMostSigBits;
-  private final long keyLeastSigBits;
-
   @Override
   public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof UUID) {
-      UUID uuid = (UUID) k;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof UUID) {
+      UUID uuid = (UUID) key;
       return uuid.getLeastSignificantBits() == this.keyLeastSigBits
           && uuid.getMostSignificantBits() == this.keyMostSigBits;
     }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapIntKey.java
index 39b5236..331c253 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapIntKey.java
@@ -19,35 +19,50 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMThinDiskLRURegionEntryHeapIntKey extends VMThinDiskLRURegionEntryHeap {
-  public VMThinDiskLRURegionEntryHeapIntKey(RegionEntryContext context, int key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMThinDiskLRURegionEntryHeapIntKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapIntKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final int key;
+
+  public VMThinDiskLRURegionEntryHeapIntKey(final RegionEntryContext context, final int key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -55,77 +70,65 @@ public class VMThinDiskLRURegionEntryHeapIntKey extends VMThinDiskLRURegionEntry
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMThinDiskLRURegionEntryHeapIntKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapIntKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -134,48 +137,43 @@ public class VMThinDiskLRURegionEntryHeapIntKey extends VMThinDiskLRURegionEntry
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -183,6 +181,7 @@ public class VMThinDiskLRURegionEntryHeapIntKey extends VMThinDiskLRURegionEntry
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -192,48 +191,57 @@ public class VMThinDiskLRURegionEntryHeapIntKey extends VMThinDiskLRURegionEntry
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -244,19 +252,17 @@ public class VMThinDiskLRURegionEntryHeapIntKey extends VMThinDiskLRURegionEntry
     return null;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final int key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Integer) {
-      return ((Integer) k).intValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Integer) {
+      return ((Integer) key).intValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapLongKey.java
index 80f0a07..4e74b0e 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapLongKey.java
@@ -19,35 +19,50 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMThinDiskLRURegionEntryHeapLongKey extends VMThinDiskLRURegionEntryHeap {
-  public VMThinDiskLRURegionEntryHeapLongKey(RegionEntryContext context, long key, Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMThinDiskLRURegionEntryHeapLongKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapLongKey.class, "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final long key;
+
+  public VMThinDiskLRURegionEntryHeapLongKey(final RegionEntryContext context, final long key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -55,77 +70,65 @@ public class VMThinDiskLRURegionEntryHeapLongKey extends VMThinDiskLRURegionEntr
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMThinDiskLRURegionEntryHeapLongKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapLongKey.class, "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -134,48 +137,43 @@ public class VMThinDiskLRURegionEntryHeapLongKey extends VMThinDiskLRURegionEntr
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
+  }
+
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
   }
 
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -183,6 +181,7 @@ public class VMThinDiskLRURegionEntryHeapLongKey extends VMThinDiskLRURegionEntr
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -192,48 +191,57 @@ public class VMThinDiskLRURegionEntryHeapLongKey extends VMThinDiskLRURegionEntr
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int size;
 
-  public void setNextLRUNode(LRUClockNode next) {
-    this.nextLRU = next;
+  @Override
+  public void setNextLRUNode(final LRUClockNode nextLRU) {
+    this.nextLRU = nextLRU;
   }
 
+  @Override
   public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
 
-  public void setPrevLRUNode(LRUClockNode prev) {
-    this.prevLRU = prev;
+  @Override
+  public void setPrevLRUNode(final LRUClockNode previousLRU) {
+    this.previousLRU = previousLRU;
   }
 
+  @Override
   public LRUClockNode prevLRUNode() {
-    return this.prevLRU;
+    return this.previousLRU;
   }
 
+  @Override
   public int getEntrySize() {
     return this.size;
   }
 
-  protected void setEntrySize(int size) {
+  protected void setEntrySize(final int size) {
     this.size = size;
   }
 
@@ -244,19 +252,17 @@ public class VMThinDiskLRURegionEntryHeapLongKey extends VMThinDiskLRURegionEntr
     return null;
   }
 
+  // ----------------------------------------- key code -------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // key code
-  private final long key;
-
   @Override
   public Object getKey() {
     return this.key;
   }
 
   @Override
-  public boolean isKeyEqual(Object k) {
-    if (k instanceof Long) {
-      return ((Long) k).longValue() == this.key;
+  public boolean isKeyEqual(final Object key) {
+    if (key instanceof Long) {
+      return ((Long) key).longValue() == this.key;
     }
     return false;
   }
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapObjectKey.java
index b9a08f9..d201146 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/entries/VMThinDiskLRURegionEntryHeapObjectKey.java
@@ -19,36 +19,51 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import org.apache.geode.internal.cache.RegionEntryContext;
 import org.apache.geode.internal.cache.lru.EnableLRU;
+import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
 import org.apache.geode.internal.cache.DiskId;
 import org.apache.geode.internal.cache.DiskStoreImpl;
 import org.apache.geode.internal.cache.PlaceHolderDiskRegion;
 import org.apache.geode.internal.cache.RegionEntry;
-import org.apache.geode.internal.cache.persistence.DiskRecoveryStore;
-import org.apache.geode.internal.cache.LocalRegion;
+import org.apache.geode.internal.cache.InternalRegion;
 import org.apache.geode.internal.cache.lru.LRUClockNode;
 import org.apache.geode.internal.cache.lru.NewLRUClockHand;
 import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry;
 
-// macros whose definition changes this class:
-// disk: DISK
-// lru: LRU
-// stats: STATS
-// versioned: VERSIONED
-// offheap: OFFHEAP
-// One of the following key macros must be defined:
-// key object: KEY_OBJECT
-// key int: KEY_INT
-// key long: KEY_LONG
-// key uuid: KEY_UUID
-// key string1: KEY_STRING1
-// key string2: KEY_STRING2
+/*
+ * macros whose definition changes this class:
+ *
+ * disk: DISK lru: LRU stats: STATS versioned: VERSIONED offheap: OFFHEAP
+ *
+ * One of the following key macros must be defined:
+ *
+ * key object: KEY_OBJECT key int: KEY_INT key long: KEY_LONG key uuid: KEY_UUID key string1:
+ * KEY_STRING1 key string2: KEY_STRING2
+ */
 /**
  * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run
  * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory).
  */
 public class VMThinDiskLRURegionEntryHeapObjectKey extends VMThinDiskLRURegionEntryHeap {
-  public VMThinDiskLRURegionEntryHeapObjectKey(RegionEntryContext context, Object key,
-      Object value) {
+  // --------------------------------------- common fields ----------------------------------------
+  private static final AtomicLongFieldUpdater<VMThinDiskLRURegionEntryHeapObjectKey> LAST_MODIFIED_UPDATER =
+      AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapObjectKey.class,
+          "lastModified");
+  protected int hash;
+  private HashEntry<Object, Object> nextEntry;
+  @SuppressWarnings("unused")
+  private volatile long lastModified;
+  private volatile Object value;
+  // ---------------------------------------- disk fields -----------------------------------------
+  /**
+   * @since GemFire 5.1
+   */
+  protected DiskId id;
+  // ----------------------------------------- key code -------------------------------------------
+  // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  private final Object key;
+
+  public VMThinDiskLRURegionEntryHeapObjectKey(final RegionEntryContext context, final Object key,
+      final Object value) {
     super(context, (value instanceof RecoveredEntry ? null : value));
     // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
     initialize(context, value);
@@ -56,78 +71,65 @@ public class VMThinDiskLRURegionEntryHeapObjectKey extends VMThinDiskLRURegionEn
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // common code
-  protected int hash;
-  private HashEntry<Object, Object> next;
-  @SuppressWarnings("unused")
-  private volatile long lastModified;
-  private static final AtomicLongFieldUpdater<VMThinDiskLRURegionEntryHeapObjectKey> lastModifiedUpdater =
-      AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapObjectKey.class,
-          "lastModified");
-  private volatile Object value;
-
   @Override
   protected Object getValueField() {
     return this.value;
   }
 
   @Override
-  protected void setValueField(Object v) {
-    this.value = v;
+  protected void setValueField(final Object value) {
+    this.value = value;
   }
 
+  @Override
   protected long getLastModifiedField() {
-    return lastModifiedUpdater.get(this);
+    return LAST_MODIFIED_UPDATER.get(this);
   }
 
-  protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
-    return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
+  @Override
+  protected boolean compareAndSetLastModifiedField(final long expectedValue, final long newValue) {
+    return LAST_MODIFIED_UPDATER.compareAndSet(this, expectedValue, newValue);
   }
 
-  /**
-   * @see HashEntry#getEntryHash()
-   */
+  @Override
   public int getEntryHash() {
     return this.hash;
   }
 
-  protected void setEntryHash(int v) {
-    this.hash = v;
+  @Override
+  protected void setEntryHash(final int hash) {
+    this.hash = hash;
   }
 
-  /**
-   * @see HashEntry#getNextEntry()
-   */
+  @Override
   public HashEntry<Object, Object> getNextEntry() {
-    return this.next;
+    return this.nextEntry;
   }
 
-  /**
-   * @see HashEntry#setNextEntry
-   */
-  public void setNextEntry(final HashEntry<Object, Object> n) {
-    this.next = n;
+  @Override
+  public void setNextEntry(final HashEntry<Object, Object> nextEntry) {
+    this.nextEntry = nextEntry;
   }
 
+  // ----------------------------------------- disk code ------------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // disk code
-  protected void initialize(RegionEntryContext drs, Object value) {
+  protected void initialize(final RegionEntryContext context, final Object value) {
     boolean isBackup;
-    if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
-    } else if (drs instanceof PlaceHolderDiskRegion) {
+    if (context instanceof InternalRegion) {
+      isBackup = ((InternalRegion) context).getDiskRegion().isBackup();
+    } else if (context instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
-      throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion");
+      throw new IllegalArgumentException("expected a InternalRegion or PlaceHolderDiskRegion");
     }
     // Delay the initialization of DiskID if overflow only
     if (isBackup) {
-      diskInitialize(drs, value);
+      diskInitialize(context, value);
     }
   }
 
   @Override
-  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(final EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -136,48 +138,43 @@ public class VMThinDiskLRURegionEntryHeapObjectKey extends VMThinDiskLRURegionEn
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
-    DiskStoreImpl ds = drs.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
-    this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
-    Helper.initialize(this, drs, value);
-  }
-
-  /**
-   * DiskId
-   * 
-   * @since GemFire 5.1
-   */
-  protected DiskId id;// = new DiskId();
-
+  @Override
   public DiskId getDiskId() {
     return this.id;
   }
 
   @Override
-  public void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
+  public void setDiskId(final RegionEntry oldEntry) {
+    this.id = ((DiskEntry) oldEntry).getDiskId();
   }
 
+  private void diskInitialize(final RegionEntryContext context, final Object value) {
+    DiskRecoveryStore diskRecoveryStore = (DiskRecoveryStore) context;
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    // get appropriate instance of DiskId implementation based on maxOplogSize
+    this.id = DiskId.createDiskId(maxOplogSize, true, diskStore.needsLinkedList());
+    Helper.initialize(this, diskRecoveryStore, value);
+  }
+
+  // --------------------------------------- eviction code ----------------------------------------
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // lru code
   @Override
-  public void setDelayedDiskId(LocalRegion r) {
-    DiskStoreImpl ds = r.getDiskStore();
-    long maxOplogSize = ds.getMaxOplogSize();
-    this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList());
+  public void setDelayedDiskId(final DiskRecoveryStore diskRecoveryStore) {
+    DiskStoreImpl diskStore = diskRecoveryStore.getDiskStore();
+    long maxOplogSize = diskStore.getMaxOplogSize();
+    this.id = DiskId.createDiskId(maxOplogSize, false, diskStore.needsLinkedList());
   }
 
-  public synchronized int updateEntrySize(EnableLRU capacityController) {
-    return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing
-                                                             // refcount because we are synced and
-                                                             // only getting the size
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController) {
+    // OFFHEAP: getValue ok w/o incing refcount because we are synced and only getting the size
+    return updateEntrySize(capacityController, getValue());
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  @Override
+  public synchronized int updateEntrySize(final EnableLRU capacityController, final Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize(getKeyForSizing(), value);
     setEntrySize(newSize);
@@ -185,6 +182,7 @@ public class VMThinDiskLRURegionEntryHeapObjectKey extends VMThinDiskLRURegionEn
     return delta;
   }
 
+  @Override
   public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
@@ -194,48 +192,57 @@ public class VMThinDiskLRURegionEntryHeapObjectKey extends VMThinDiskLRURegionEn
     setBits(RECENTLY_USED);
   }
 
+  @Override
   public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
 
+  @Override
   public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
 
+  @Override
   public void setEvicted() {
     setBits(EVICTED);
   }
 
+  @Override
   public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   private LRUClockNode nextLRU;
-  private LRUClockNode prevLRU;
+  private LRUClockNode previousLRU;
   private int s