geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kl...@apache.org
Subject [37/78] geode git commit: GEODE-2929: Remove superfluous final from internal methods
Date Tue, 16 May 2017 02:19:47 GMT
GEODE-2929: Remove superfluous final from internal methods


Project: http://git-wip-us.apache.org/repos/asf/geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/geode/commit/30f455bb
Tree: http://git-wip-us.apache.org/repos/asf/geode/tree/30f455bb
Diff: http://git-wip-us.apache.org/repos/asf/geode/diff/30f455bb

Branch: refs/heads/feature/GEODE-2929
Commit: 30f455bba372caf2d602a88c6f1eef85b3c94538
Parents: a63457b
Author: Kirk Lund <klund@apache.org>
Authored: Mon May 15 16:54:47 2017 -0700
Committer: Kirk Lund <klund@apache.org>
Committed: Mon May 15 16:54:47 2017 -0700

----------------------------------------------------------------------
 .../cache/AbstractOplogDiskRegionEntry.java     |  16 +-
 .../geode/internal/cache/LeafRegionEntry.cpp    |  79 ++--
 .../internal/cache/NonLocalRegionEntry.java     |   4 +-
 .../VMStatsDiskLRURegionEntryHeapIntKey.java    | 317 +++++++-------
 .../VMStatsDiskLRURegionEntryHeapLongKey.java   | 312 +++++++-------
 .../VMStatsDiskLRURegionEntryHeapObjectKey.java | 311 +++++++-------
 ...VMStatsDiskLRURegionEntryHeapStringKey1.java | 336 ++++++++-------
 ...VMStatsDiskLRURegionEntryHeapStringKey2.java | 337 ++++++++-------
 .../VMStatsDiskLRURegionEntryHeapUUIDKey.java   | 313 +++++++-------
 .../VMStatsDiskLRURegionEntryOffHeapIntKey.java | 369 +++++++++--------
 ...VMStatsDiskLRURegionEntryOffHeapLongKey.java | 364 ++++++++--------
 ...StatsDiskLRURegionEntryOffHeapObjectKey.java | 360 ++++++++--------
 ...tatsDiskLRURegionEntryOffHeapStringKey1.java | 385 +++++++++--------
 ...tatsDiskLRURegionEntryOffHeapStringKey2.java | 386 +++++++++--------
 ...VMStatsDiskLRURegionEntryOffHeapUUIDKey.java | 365 ++++++++--------
 .../cache/VMStatsDiskRegionEntryHeapIntKey.java | 227 ++++++----
 .../VMStatsDiskRegionEntryHeapLongKey.java      | 222 ++++++----
 .../VMStatsDiskRegionEntryHeapObjectKey.java    | 217 ++++++----
 .../VMStatsDiskRegionEntryHeapStringKey1.java   | 243 ++++++-----
 .../VMStatsDiskRegionEntryHeapStringKey2.java   | 244 ++++++-----
 .../VMStatsDiskRegionEntryHeapUUIDKey.java      | 223 ++++++----
 .../VMStatsDiskRegionEntryOffHeapIntKey.java    | 273 +++++++-----
 .../VMStatsDiskRegionEntryOffHeapLongKey.java   | 268 +++++++-----
 .../VMStatsDiskRegionEntryOffHeapObjectKey.java | 266 +++++++-----
 ...VMStatsDiskRegionEntryOffHeapStringKey1.java | 291 +++++++------
 ...VMStatsDiskRegionEntryOffHeapStringKey2.java | 292 +++++++------
 .../VMStatsDiskRegionEntryOffHeapUUIDKey.java   | 269 +++++++-----
 .../cache/VMStatsLRURegionEntryHeapIntKey.java  | 217 ++++++----
 .../cache/VMStatsLRURegionEntryHeapLongKey.java | 212 ++++++----
 .../VMStatsLRURegionEntryHeapObjectKey.java     | 207 +++++----
 .../VMStatsLRURegionEntryHeapStringKey1.java    | 231 ++++++-----
 .../VMStatsLRURegionEntryHeapStringKey2.java    | 232 ++++++-----
 .../cache/VMStatsLRURegionEntryHeapUUIDKey.java | 204 +++++----
 .../VMStatsLRURegionEntryOffHeapIntKey.java     | 266 +++++++-----
 .../VMStatsLRURegionEntryOffHeapLongKey.java    | 261 +++++++-----
 .../VMStatsLRURegionEntryOffHeapObjectKey.java  | 258 +++++++-----
 .../VMStatsLRURegionEntryOffHeapStringKey1.java | 282 +++++++------
 .../VMStatsLRURegionEntryOffHeapStringKey2.java | 283 +++++++------
 .../VMStatsLRURegionEntryOffHeapUUIDKey.java    | 253 ++++++-----
 .../cache/VMStatsRegionEntryHeapIntKey.java     | 125 ++++--
 .../cache/VMStatsRegionEntryHeapLongKey.java    | 120 ++++--
 .../cache/VMStatsRegionEntryHeapObjectKey.java  | 115 +++--
 .../cache/VMStatsRegionEntryHeapStringKey1.java | 139 ++++---
 .../cache/VMStatsRegionEntryHeapStringKey2.java | 140 ++++---
 .../cache/VMStatsRegionEntryHeapUUIDKey.java    | 112 +++--
 .../cache/VMStatsRegionEntryOffHeapIntKey.java  | 167 +++++---
 .../cache/VMStatsRegionEntryOffHeapLongKey.java | 162 +++++---
 .../VMStatsRegionEntryOffHeapObjectKey.java     | 157 ++++---
 .../VMStatsRegionEntryOffHeapStringKey1.java    | 180 ++++----
 .../VMStatsRegionEntryOffHeapStringKey2.java    | 181 ++++----
 .../cache/VMStatsRegionEntryOffHeapUUIDKey.java | 154 ++++---
 .../VMThinDiskLRURegionEntryHeapIntKey.java     | 274 ++++++------
 .../VMThinDiskLRURegionEntryHeapLongKey.java    | 269 ++++++------
 .../VMThinDiskLRURegionEntryHeapObjectKey.java  | 262 ++++++------
 .../VMThinDiskLRURegionEntryHeapStringKey1.java | 291 +++++++------
 .../VMThinDiskLRURegionEntryHeapStringKey2.java | 292 +++++++------
 .../VMThinDiskLRURegionEntryHeapUUIDKey.java    | 270 ++++++------
 .../VMThinDiskLRURegionEntryOffHeapIntKey.java  | 324 +++++++++------
 .../VMThinDiskLRURegionEntryOffHeapLongKey.java | 319 ++++++++------
 ...MThinDiskLRURegionEntryOffHeapObjectKey.java | 315 ++++++++------
 ...ThinDiskLRURegionEntryOffHeapStringKey1.java | 340 ++++++++-------
 ...ThinDiskLRURegionEntryOffHeapStringKey2.java | 341 ++++++++-------
 .../VMThinDiskLRURegionEntryOffHeapUUIDKey.java | 320 ++++++++------
 .../cache/VMThinDiskRegionEntryHeapIntKey.java  | 186 ++++++---
 .../cache/VMThinDiskRegionEntryHeapLongKey.java | 181 +++++---
 .../VMThinDiskRegionEntryHeapObjectKey.java     | 174 +++++---
 .../VMThinDiskRegionEntryHeapStringKey1.java    | 198 +++++----
 .../VMThinDiskRegionEntryHeapStringKey2.java    | 199 +++++----
 .../cache/VMThinDiskRegionEntryHeapUUIDKey.java | 182 +++++---
 .../VMThinDiskRegionEntryOffHeapIntKey.java     | 228 ++++++----
 .../VMThinDiskRegionEntryOffHeapLongKey.java    | 223 ++++++----
 .../VMThinDiskRegionEntryOffHeapObjectKey.java  | 219 ++++++----
 .../VMThinDiskRegionEntryOffHeapStringKey1.java | 240 ++++++-----
 .../VMThinDiskRegionEntryOffHeapStringKey2.java | 241 ++++++-----
 .../VMThinDiskRegionEntryOffHeapUUIDKey.java    | 220 ++++++----
 .../cache/VMThinLRURegionEntryHeapIntKey.java   | 174 +++++---
 .../cache/VMThinLRURegionEntryHeapLongKey.java  | 169 +++++---
 .../VMThinLRURegionEntryHeapObjectKey.java      | 164 +++++---
 .../VMThinLRURegionEntryHeapStringKey1.java     | 188 +++++----
 .../VMThinLRURegionEntryHeapStringKey2.java     | 189 +++++----
 .../cache/VMThinLRURegionEntryHeapUUIDKey.java  | 161 ++++---
 .../VMThinLRURegionEntryOffHeapIntKey.java      | 223 ++++++----
 .../VMThinLRURegionEntryOffHeapLongKey.java     | 218 ++++++----
 .../VMThinLRURegionEntryOffHeapObjectKey.java   | 213 ++++++----
 .../VMThinLRURegionEntryOffHeapStringKey1.java  | 237 ++++++-----
 .../VMThinLRURegionEntryOffHeapStringKey2.java  | 238 ++++++-----
 .../VMThinLRURegionEntryOffHeapUUIDKey.java     | 210 ++++++----
 .../cache/VMThinRegionEntryHeapIntKey.java      |  81 +++-
 .../cache/VMThinRegionEntryHeapLongKey.java     |  76 +++-
 .../cache/VMThinRegionEntryHeapObjectKey.java   |  71 +++-
 .../cache/VMThinRegionEntryHeapStringKey1.java  |  95 +++--
 .../cache/VMThinRegionEntryHeapStringKey2.java  |  96 +++--
 .../cache/VMThinRegionEntryHeapUUIDKey.java     |  68 ++-
 .../cache/VMThinRegionEntryOffHeapIntKey.java   | 123 ++++--
 .../cache/VMThinRegionEntryOffHeapLongKey.java  | 118 ++++--
 .../VMThinRegionEntryOffHeapObjectKey.java      | 113 +++--
 .../VMThinRegionEntryOffHeapStringKey1.java     | 136 +++---
 .../VMThinRegionEntryOffHeapStringKey2.java     | 137 +++---
 .../cache/VMThinRegionEntryOffHeapUUIDKey.java  | 110 +++--
 ...sionedStatsDiskLRURegionEntryHeapIntKey.java | 362 ++++++++--------
 ...ionedStatsDiskLRURegionEntryHeapLongKey.java | 357 ++++++++--------
 ...nedStatsDiskLRURegionEntryHeapObjectKey.java | 352 +++++++++-------
 ...edStatsDiskLRURegionEntryHeapStringKey1.java | 377 +++++++++--------
 ...edStatsDiskLRURegionEntryHeapStringKey2.java | 378 +++++++++--------
 ...ionedStatsDiskLRURegionEntryHeapUUIDKey.java | 358 ++++++++--------
 ...nedStatsDiskLRURegionEntryOffHeapIntKey.java | 399 ++++++++++--------
 ...edStatsDiskLRURegionEntryOffHeapLongKey.java | 394 ++++++++++--------
 ...StatsDiskLRURegionEntryOffHeapObjectKey.java | 389 +++++++++--------
 ...tatsDiskLRURegionEntryOffHeapStringKey1.java | 414 +++++++++---------
 ...tatsDiskLRURegionEntryOffHeapStringKey2.java | 415 ++++++++++---------
 ...edStatsDiskLRURegionEntryOffHeapUUIDKey.java | 395 ++++++++++--------
 ...VersionedStatsDiskRegionEntryHeapIntKey.java | 277 ++++++++-----
 ...ersionedStatsDiskRegionEntryHeapLongKey.java | 272 +++++++-----
 ...sionedStatsDiskRegionEntryHeapObjectKey.java | 267 +++++++-----
 ...ionedStatsDiskRegionEntryHeapStringKey1.java | 292 +++++++------
 ...ionedStatsDiskRegionEntryHeapStringKey2.java | 293 +++++++------
 ...ersionedStatsDiskRegionEntryHeapUUIDKey.java | 273 +++++++-----
 ...sionedStatsDiskRegionEntryOffHeapIntKey.java | 317 ++++++++------
 ...ionedStatsDiskRegionEntryOffHeapLongKey.java | 312 ++++++++------
 ...nedStatsDiskRegionEntryOffHeapObjectKey.java | 307 ++++++++------
 ...edStatsDiskRegionEntryOffHeapStringKey1.java | 332 ++++++++-------
 ...edStatsDiskRegionEntryOffHeapStringKey2.java | 333 ++++++++-------
 ...ionedStatsDiskRegionEntryOffHeapUUIDKey.java | 313 ++++++++------
 .../VersionedStatsLRURegionEntryHeapIntKey.java | 258 +++++++-----
 ...VersionedStatsLRURegionEntryHeapLongKey.java | 254 +++++++-----
 ...rsionedStatsLRURegionEntryHeapObjectKey.java | 249 ++++++-----
 ...sionedStatsLRURegionEntryHeapStringKey1.java | 272 ++++++------
 ...sionedStatsLRURegionEntryHeapStringKey2.java | 273 ++++++------
 ...VersionedStatsLRURegionEntryHeapUUIDKey.java | 246 ++++++-----
 ...rsionedStatsLRURegionEntryOffHeapIntKey.java | 296 +++++++------
 ...sionedStatsLRURegionEntryOffHeapLongKey.java | 294 +++++++------
 ...onedStatsLRURegionEntryOffHeapObjectKey.java | 289 +++++++------
 ...nedStatsLRURegionEntryOffHeapStringKey1.java | 312 +++++++-------
 ...nedStatsLRURegionEntryOffHeapStringKey2.java | 313 +++++++-------
 ...sionedStatsLRURegionEntryOffHeapUUIDKey.java | 286 +++++++------
 .../VersionedStatsRegionEntryHeapIntKey.java    | 176 +++++---
 .../VersionedStatsRegionEntryHeapLongKey.java   | 171 +++++---
 .../VersionedStatsRegionEntryHeapObjectKey.java | 170 +++++---
 ...VersionedStatsRegionEntryHeapStringKey1.java | 193 +++++----
 ...VersionedStatsRegionEntryHeapStringKey2.java | 194 +++++----
 .../VersionedStatsRegionEntryHeapUUIDKey.java   | 163 +++++---
 .../VersionedStatsRegionEntryOffHeapIntKey.java | 216 ++++++----
 ...VersionedStatsRegionEntryOffHeapLongKey.java | 211 ++++++----
 ...rsionedStatsRegionEntryOffHeapObjectKey.java | 207 +++++----
 ...sionedStatsRegionEntryOffHeapStringKey1.java | 230 +++++-----
 ...sionedStatsRegionEntryOffHeapStringKey2.java | 231 ++++++-----
 ...VersionedStatsRegionEntryOffHeapUUIDKey.java | 203 +++++----
 ...rsionedThinDiskLRURegionEntryHeapIntKey.java | 314 ++++++++------
 ...sionedThinDiskLRURegionEntryHeapLongKey.java | 312 ++++++++------
 ...onedThinDiskLRURegionEntryHeapObjectKey.java | 307 ++++++++------
 ...nedThinDiskLRURegionEntryHeapStringKey1.java | 332 ++++++++-------
 ...nedThinDiskLRURegionEntryHeapStringKey2.java | 333 ++++++++-------
 ...sionedThinDiskLRURegionEntryHeapUUIDKey.java | 313 ++++++++------
 ...onedThinDiskLRURegionEntryOffHeapIntKey.java | 354 +++++++++-------
 ...nedThinDiskLRURegionEntryOffHeapLongKey.java | 349 +++++++++-------
 ...dThinDiskLRURegionEntryOffHeapObjectKey.java | 344 ++++++++-------
 ...ThinDiskLRURegionEntryOffHeapStringKey1.java | 369 +++++++++--------
 ...ThinDiskLRURegionEntryOffHeapStringKey2.java | 370 +++++++++--------
 ...nedThinDiskLRURegionEntryOffHeapUUIDKey.java | 350 +++++++++-------
 .../VersionedThinDiskRegionEntryHeapIntKey.java | 220 ++++++----
 ...VersionedThinDiskRegionEntryHeapLongKey.java | 216 ++++++----
 ...rsionedThinDiskRegionEntryHeapObjectKey.java | 211 ++++++----
 ...sionedThinDiskRegionEntryHeapStringKey1.java | 240 ++++++-----
 ...sionedThinDiskRegionEntryHeapStringKey2.java | 241 ++++++-----
 ...VersionedThinDiskRegionEntryHeapUUIDKey.java | 217 ++++++----
 ...rsionedThinDiskRegionEntryOffHeapIntKey.java | 262 +++++++-----
 ...sionedThinDiskRegionEntryOffHeapLongKey.java | 260 +++++++-----
 ...onedThinDiskRegionEntryOffHeapObjectKey.java | 255 +++++++-----
 ...nedThinDiskRegionEntryOffHeapStringKey1.java | 280 +++++++------
 ...nedThinDiskRegionEntryOffHeapStringKey2.java | 281 +++++++------
 ...sionedThinDiskRegionEntryOffHeapUUIDKey.java | 261 +++++++-----
 .../VersionedThinLRURegionEntryHeapIntKey.java  | 213 ++++++----
 .../VersionedThinLRURegionEntryHeapLongKey.java | 209 ++++++----
 ...ersionedThinLRURegionEntryHeapObjectKey.java | 204 +++++----
 ...rsionedThinLRURegionEntryHeapStringKey1.java | 227 +++++-----
 ...rsionedThinLRURegionEntryHeapStringKey2.java | 228 +++++-----
 .../VersionedThinLRURegionEntryHeapUUIDKey.java | 201 +++++----
 ...ersionedThinLRURegionEntryOffHeapIntKey.java | 251 ++++++-----
 ...rsionedThinLRURegionEntryOffHeapLongKey.java | 246 ++++++-----
 ...ionedThinLRURegionEntryOffHeapObjectKey.java | 244 ++++++-----
 ...onedThinLRURegionEntryOffHeapStringKey1.java | 267 +++++++-----
 ...onedThinLRURegionEntryOffHeapStringKey2.java | 268 ++++++------
 ...rsionedThinLRURegionEntryOffHeapUUIDKey.java | 238 ++++++-----
 .../VersionedThinRegionEntryHeapIntKey.java     | 120 ++++--
 .../VersionedThinRegionEntryHeapLongKey.java    | 115 +++--
 .../VersionedThinRegionEntryHeapObjectKey.java  | 112 +++--
 .../VersionedThinRegionEntryHeapStringKey1.java | 135 +++---
 .../VersionedThinRegionEntryHeapStringKey2.java | 136 +++---
 .../VersionedThinRegionEntryHeapUUIDKey.java    | 107 +++--
 .../VersionedThinRegionEntryOffHeapIntKey.java  | 158 ++++---
 .../VersionedThinRegionEntryOffHeapLongKey.java | 153 ++++---
 ...ersionedThinRegionEntryOffHeapObjectKey.java | 149 ++++---
 ...rsionedThinRegionEntryOffHeapStringKey1.java | 172 +++++---
 ...rsionedThinRegionEntryOffHeapStringKey2.java | 173 +++++---
 .../VersionedThinRegionEntryOffHeapUUIDKey.java | 145 ++++---
 195 files changed, 27295 insertions(+), 19715 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/geode/blob/30f455bb/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractOplogDiskRegionEntry.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractOplogDiskRegionEntry.java b/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractOplogDiskRegionEntry.java
index bdaf200..866ff03 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractOplogDiskRegionEntry.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/AbstractOplogDiskRegionEntry.java
@@ -54,29 +54,29 @@ public abstract class AbstractOplogDiskRegionEntry extends AbstractDiskRegionEnt
   }
 
   @Override
-  public final boolean fillInValue(LocalRegion r, InitialImageOperation.Entry entry,
+  public boolean fillInValue(LocalRegion r, InitialImageOperation.Entry entry,
       ByteArrayDataInput in, DM mgr) {
     return Helper.fillInValue(this, entry, r.getDiskRegion(), mgr, in, r);
   }
 
   @Override
-  public final boolean isOverflowedToDisk(LocalRegion r, DistributedRegion.DiskPosition dp) {
+  public boolean isOverflowedToDisk(LocalRegion r, DistributedRegion.DiskPosition dp) {
     return Helper.isOverflowedToDisk(this, r.getDiskRegion(), dp, r);
   }
 
   @Override
-  public final Object getValue(RegionEntryContext context) {
+  public Object getValue(RegionEntryContext context) {
     return Helper.faultInValue(this, (LocalRegion) context); // OFFHEAP returned to callers
   }
 
   @Override
   @Retained
-  public final Object getValueRetain(RegionEntryContext context) {
+  public Object getValueRetain(RegionEntryContext context) {
     return Helper.faultInValueRetain(this, (LocalRegion) context);
   }
 
   @Override
-  public final Object getValueInVMOrDiskWithoutFaultIn(LocalRegion owner) {
+  public Object getValueInVMOrDiskWithoutFaultIn(LocalRegion owner) {
     return Helper.getValueInVMOrDiskWithoutFaultIn(this, owner);
   }
 
@@ -87,17 +87,17 @@ public abstract class AbstractOplogDiskRegionEntry extends AbstractDiskRegionEnt
   }
 
   @Override
-  public final Object getValueOnDisk(LocalRegion r) throws EntryNotFoundException {
+  public Object getValueOnDisk(LocalRegion r) throws EntryNotFoundException {
     return Helper.getValueOnDisk(this, r.getDiskRegion());
   }
 
   @Override
-  public final Object getSerializedValueOnDisk(LocalRegion r) throws EntryNotFoundException {
+  public Object getSerializedValueOnDisk(LocalRegion r) throws EntryNotFoundException {
     return Helper.getSerializedValueOnDisk(this, r.getDiskRegion());
   }
 
   @Override
-  public final Object getValueOnDiskOrBuffer(LocalRegion r) throws EntryNotFoundException {
+  public Object getValueOnDiskOrBuffer(LocalRegion r) throws EntryNotFoundException {
     // @todo darrel if value is Token.REMOVED || Token.DESTROYED throw
     // EntryNotFoundException
     return Helper.getValueOnDiskOrBuffer(this, r.getDiskRegion(), r);

http://git-wip-us.apache.org/repos/asf/geode/blob/30f455bb/geode-core/src/main/java/org/apache/geode/internal/cache/LeafRegionEntry.cpp
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/LeafRegionEntry.cpp b/geode-core/src/main/java/org/apache/geode/internal/cache/LeafRegionEntry.cpp
index 596e031..cb3ce3b 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/LeafRegionEntry.cpp
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/LeafRegionEntry.cpp
@@ -246,7 +246,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
 #else    
   private volatile Object value;
   @Override
-  protected final Object getValueField() {
+  protected Object getValueField() {
     return this.value;
   }
   @Override
@@ -263,7 +263,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
   /**
    * @see HashEntry#getEntryHash()
    */
-  public final int getEntryHash() {
+  public int getEntryHash() {
     return this.hash;
   }
   protected void setEntryHash(int v) {
@@ -272,13 +272,13 @@ public class LEAF_CLASS extends PARENT_CLASS {
   /**
    * @see HashEntry#getNextEntry()
    */
-  public final HashEntry<Object, Object> getNextEntry() {
+  public HashEntry<Object, Object> getNextEntry() {
     return this.next;
   }
   /**
    * @see HashEntry#setNextEntry
    */
-  public final void setNextEntry(final HashEntry<Object, Object> n) {
+  public void setNextEntry(final HashEntry<Object, Object> n) {
     this.next = n;
   }
 #ifdef DISK
@@ -302,7 +302,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
     }
   }
   @Override
-  public final synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize( getKeyForSizing(), null);
     setEntrySize(newSize);
@@ -398,43 +398,37 @@ public class LEAF_CLASS extends PARENT_CLASS {
   // nothing needed for LRUs with no disk
 #endif
   }
-  public final synchronized int updateEntrySize(EnableLRU capacityController) {
+  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
   }
   
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
-  public final synchronized int updateEntrySize(EnableLRU capacityController,
+  public synchronized int updateEntrySize(EnableLRU capacityController,
                                                 Object value) {
     int oldSize = getEntrySize();
     int newSize = capacityController.entrySize( getKeyForSizing(), value);
     setEntrySize(newSize);
     int delta = newSize - oldSize;
-  //   if ( debug ) log( "updateEntrySize key=" + getKey()
-  //                     + (_getValue() == Token.INVALID ? " invalid" :
-  //                        (_getValue() == Token.LOCAL_INVALID ? "local_invalid" :
-  //                         (_getValue()==null ? " evicted" : " valid")))
-  //                     + " oldSize=" + oldSize
-  //                     + " newSize=" + this.size );
     return delta;
   }
-  public final boolean testRecentlyUsed() {
+  public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
   @Override
-  public final void setRecentlyUsed() {
+  public void setRecentlyUsed() {
     setBits(RECENTLY_USED);
   }
-  public final void unsetRecentlyUsed() {
+  public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
-  public final boolean testEvicted() {
+  public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
-  public final void setEvicted() {
+  public void setEvicted() {
     setBits(EVICTED);
   }
-  public final void unsetEvicted() {
+  public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
@@ -443,35 +437,27 @@ public class LEAF_CLASS extends PARENT_CLASS {
   private LRUClockNode nextLRU;
   private LRUClockNode prevLRU;
   private int size;
-  public final void setNextLRUNode( LRUClockNode next ) {
+  public void setNextLRUNode( LRUClockNode next ) {
     this.nextLRU = next;
   }
-  public final LRUClockNode nextLRUNode() {
+  public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
-  public final void setPrevLRUNode( LRUClockNode prev ) {
+  public void setPrevLRUNode( LRUClockNode prev ) {
     this.prevLRU = prev;
   }
-  public final LRUClockNode prevLRUNode() {
+  public LRUClockNode prevLRUNode() {
     return this.prevLRU;
   }
-  public final int getEntrySize() {
+  public int getEntrySize() {
     return this.size;
   }
-  protected final void setEntrySize(int size) {
+  protected void setEntrySize(int size) {
     this.size = size;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
-//@Override
-//public StringBuilder appendFieldsToString(final StringBuilder sb) {
-//  StringBuilder result = super.appendFieldsToString(sb);
-//  result.append("; prev=").append(this.prevLRU==null?"null":"not null");
-//  result.append("; next=").append(this.nextLRU==null?"null":"not null");
-//  return result;
-//}
-  
   @Override
   public Object getKeyForSizing() {
 #ifdef KEY_OBJECT
@@ -489,8 +475,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
   
   // stats code
   @Override
-  public final void updateStatsForGet(boolean hit, long time)
-  {
+  public void updateStatsForGet(boolean hit, long time) {
     setLastAccessed(time);
     if (hit) {
       incrementHitCount();
@@ -499,7 +484,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
     }
   }
   @Override
-  protected final void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
     _setLastModified(lastModified);
     if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { 
       setLastAccessed(lastAccessed);
@@ -515,18 +500,18 @@ public class LEAF_CLASS extends PARENT_CLASS {
     = AtomicIntegerFieldUpdater.newUpdater(LEAF_CLASS.class, "missCount");
   
   @Override
-  public final long getLastAccessed() throws InternalStatisticsDisabledException {
+  public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
   private void setLastAccessed(long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
   @Override
-  public final long getHitCount() throws InternalStatisticsDisabledException {
+  public long getHitCount() throws InternalStatisticsDisabledException {
     return this.hitCount & 0xFFFFFFFFL;
   }
   @Override
-  public final long getMissCount() throws InternalStatisticsDisabledException {
+  public long getMissCount() throws InternalStatisticsDisabledException {
     return this.missCount & 0xFFFFFFFFL;
   }
   private void incrementHitCount() {
@@ -536,7 +521,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
     missCountUpdater.incrementAndGet(this);
   }
   @Override
-  public final void resetCounts() throws InternalStatisticsDisabledException {
+  public void resetCounts() throws InternalStatisticsDisabledException {
     hitCountUpdater.set(this,0);
     missCountUpdater.set(this,0);
   }
@@ -544,7 +529,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
   
   @Override
-  public final void txDidDestroy(long currTime) {
+  public void txDidDestroy(long currTime) {
     setLastModified(currTime);
     setLastAccessed(currTime);
     this.hitCount = 0;
@@ -662,14 +647,14 @@ public class LEAF_CLASS extends PARENT_CLASS {
 #ifdef KEY_OBJECT
   private final Object key;
   @Override
-  public final Object getKey() {
+  public Object getKey() {
     return this.key;
   }
 
 #elif defined(KEY_INT)
   private final int key;
   @Override
-  public final Object getKey() {
+  public Object getKey() {
     return this.key;
   }
   @Override
@@ -683,7 +668,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
 #elif defined(KEY_LONG)
   private final long key;
   @Override
-  public final Object getKey() {
+  public Object getKey() {
     return this.key;
   }
   @Override
@@ -698,7 +683,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
   private final long keyMostSigBits;
   private final long keyLeastSigBits;
   @Override
-  public final Object getKey() {
+  public Object getKey() {
     return new UUID(this.keyMostSigBits, this.keyLeastSigBits);
   }
   @Override
@@ -722,7 +707,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
     return (int) (this.bits1 >> 6) & 0x03;
   }
   @Override
-  public final Object getKey() {
+  public Object getKey() {
     int keylen = getKeyLength();
     char[] chars = new char[keylen];
     long tmpBits1 = this.bits1;
@@ -788,7 +773,7 @@ public class LEAF_CLASS extends PARENT_CLASS {
     return (int) (this.bits1 >> 6) & 0x03;
   }
   @Override
-  public final Object getKey() {
+  public Object getKey() {
     int keylen = getKeyLength();
     char[] chars = new char[keylen];
     long tmpBits1 = this.bits1;

http://git-wip-us.apache.org/repos/asf/geode/blob/30f455bb/geode-core/src/main/java/org/apache/geode/internal/cache/NonLocalRegionEntry.java
----------------------------------------------------------------------
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 bfcf6ff..805b900 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
@@ -203,12 +203,12 @@ public class NonLocalRegionEntry implements RegionEntry, VersionStamp {
     return this.key;
   }
 
-  public final Object getValue(RegionEntryContext context) {
+  public Object getValue(RegionEntryContext context) {
     return this.value;
   }
 
   @Override
-  public final Object getValueRetain(RegionEntryContext context) {
+  public Object getValueRetain(RegionEntryContext context) {
     return this.value;
   }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/30f455bb/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapIntKey.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapIntKey.java
index e2043f2..f179ab6 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapIntKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapIntKey.java
@@ -15,55 +15,94 @@
 package org.apache.geode.internal.cache;
 
 // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+
+
+
+
+
+
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+
+
+
+
 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.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
+// disk: 1
+// lru: 1
+// stats: 1
 // versioned: VERSIONED
 // offheap: OFFHEAP
 // One of the following key macros must be defined:
 // key object: KEY_OBJECT
-// key int: KEY_INT
+// key int: 1
 // 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) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
+  public VMStatsDiskLRURegionEntryHeapIntKey  (RegionEntryContext context, int key, 
+
+
+
+      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
   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;
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapIntKey> lastModifiedUpdater
+    = AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapIntKey.class, "lastModified");
 
+  private volatile Object value;
   @Override
-  protected final Object getValueField() {
+  protected Object getValueField() {
     return this.value;
   }
-
   @Override
   protected void setValueField(Object v) {
     this.value = v;
@@ -72,42 +111,40 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
   protected long getLastModifiedField() {
     return lastModifiedUpdater.get(this);
   }
-
   protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
     return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
   }
-
   /**
    * @see HashEntry#getEntryHash()
    */
-  public final int getEntryHash() {
+  public int getEntryHash() {
     return this.hash;
   }
-
   protected void setEntryHash(int v) {
     this.hash = v;
   }
-
   /**
    * @see HashEntry#getNextEntry()
    */
-  public final HashEntry<Object, Object> getNextEntry() {
+  public HashEntry<Object, Object> getNextEntry() {
     return this.next;
   }
-
   /**
    * @see HashEntry#setNextEntry
    */
-  public final void setNextEntry(final HashEntry<Object, Object> n) {
+  public void setNextEntry(final HashEntry<Object, Object> n) {
     this.next = n;
   }
 
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   // disk code
+
   protected void initialize(RegionEntryContext drs, Object value) {
     boolean isBackup;
     if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
+      isBackup = ((LocalRegion)drs).getDiskRegion().isBackup();
     } else if (drs instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
@@ -118,22 +155,23 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
       diskInitialize(drs, value);
     }
   }
-
   @Override
-  public final synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(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;
   }
 
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
+    DiskRecoveryStore drs = (DiskRecoveryStore)context;
     DiskStoreImpl ds = drs.getDiskStore();
     long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
+    //get appropriate instance of DiskId implementation based on maxOplogSize
     this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
     Helper.initialize(this, drs, value);
   }
@@ -143,158 +181,147 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
    * 
    * @since GemFire 5.1
    */
-  protected DiskId id;// = new DiskId();
-
+  protected DiskId id;//= new DiskId();
   public DiskId getDiskId() {
     return this.id;
   }
-
   @Override
   void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
-  }
-
-  // // inlining DiskId
-  // // always have these fields
-  // /**
-  // * id consists of
-  // * most significant
-  // * 1 byte = users bits
-  // * 2-8 bytes = oplog id
-  // * least significant.
-  // *
-  // * The highest bit in the oplog id part is set to 1 if the oplog id
-  // * is negative.
-  // * @todo this field could be an int for an overflow only region
-  // */
-  // private long id;
-  // /**
-  // * Length of the bytes on disk.
-  // * This is always set. If the value is invalid then it will be set to 0.
-  // * The most significant bit is used by overflow to mark it as needing to be written.
-  // */
-  // protected int valueLength = 0;
-  // // have intOffset or longOffset
-  // // intOffset
-  // /**
-  // * The position in the oplog (the oplog offset) where this entry's value is
-  // * stored
-  // */
-  // private volatile int offsetInOplog;
-  // // longOffset
-  // /**
-  // * The position in the oplog (the oplog offset) where this entry's value is
-  // * stored
-  // */
-  // private volatile long offsetInOplog;
-  // // have overflowOnly or persistence
-  // // overflowOnly
-  // // no fields
-  // // persistent
-  // /** unique entry identifier * */
-  // private long keyId;
+    this.id = ((AbstractDiskRegionEntry)old).getDiskId();
+  }
+//  // inlining DiskId
+//  // always have these fields
+//  /**
+//   * id consists of
+//   * most significant
+//   * 1 byte = users bits
+//   * 2-8 bytes = oplog id
+//   * least significant.
+//   * 
+//   * The highest bit in the oplog id part is set to 1 if the oplog id
+//   * is negative.
+//   * @todo this field could be an int for an overflow only region
+//   */
+//  private long id;
+//  /**
+//   * Length of the bytes on disk.
+//   * This is always set. If the value is invalid then it will be set to 0.
+//   * The most significant bit is used by overflow to mark it as needing to be written.
+//   */
+//  protected int valueLength = 0;
+//  // have intOffset or longOffset
+//  // intOffset
+//  /**
+//   * The position in the oplog (the oplog offset) where this entry's value is
+//   * stored
+//   */
+//  private volatile int offsetInOplog;
+//  // longOffset
+//  /**
+//   * The position in the oplog (the oplog offset) where this entry's value is
+//   * stored
+//   */
+//  private volatile long offsetInOplog;
+//  // have overflowOnly or persistence
+//  // overflowOnly
+//  // no fields
+//  // persistent
+//  /** unique entry identifier * */
+//  private long keyId;
+
+  
+
   // 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 final 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
-  }
 
+
+  }
+  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
+  }
+  
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public final synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  
+  public synchronized int updateEntrySize(EnableLRU capacityController,
+                                                Object value) {
     int oldSize = getEntrySize();
-    int newSize = capacityController.entrySize(getKeyForSizing(), value);
+    int newSize = capacityController.entrySize( getKeyForSizing(), value);
     setEntrySize(newSize);
     int delta = newSize - oldSize;
-    // if ( debug ) log( "updateEntrySize key=" + getKey()
-    // + (_getValue() == Token.INVALID ? " invalid" :
-    // (_getValue() == Token.LOCAL_INVALID ? "local_invalid" :
-    // (_getValue()==null ? " evicted" : " valid")))
-    // + " oldSize=" + oldSize
-    // + " newSize=" + this.size );
     return delta;
   }
-
-  public final boolean testRecentlyUsed() {
+  public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
-
   @Override
-  public final void setRecentlyUsed() {
+  public void setRecentlyUsed() {
     setBits(RECENTLY_USED);
   }
-
-  public final void unsetRecentlyUsed() {
+  public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
-
-  public final boolean testEvicted() {
+  public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
-
-  public final void setEvicted() {
+  public void setEvicted() {
     setBits(EVICTED);
   }
-
-  public final void unsetEvicted() {
+  public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+
   private LRUClockNode nextLRU;
   private LRUClockNode prevLRU;
   private int size;
-
-  public final void setNextLRUNode(LRUClockNode next) {
+  public void setNextLRUNode( LRUClockNode next ) {
     this.nextLRU = next;
   }
-
-  public final LRUClockNode nextLRUNode() {
+  public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
-
-  public final void setPrevLRUNode(LRUClockNode prev) {
+  public void setPrevLRUNode( LRUClockNode prev ) {
     this.prevLRU = prev;
   }
-
-  public final LRUClockNode prevLRUNode() {
+  public LRUClockNode prevLRUNode() {
     return this.prevLRU;
   }
-
-  public final int getEntrySize() {
+  public int getEntrySize() {
     return this.size;
   }
-
-  protected final void setEntrySize(int size) {
+  protected void setEntrySize(int size) {
     this.size = size;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // @Override
-  // public StringBuilder appendFieldsToString(final StringBuilder sb) {
-  // StringBuilder result = super.appendFieldsToString(sb);
-  // result.append("; prev=").append(this.prevLRU==null?"null":"not null");
-  // result.append("; next=").append(this.nextLRU==null?"null":"not null");
-  // return result;
-  // }
+  
   @Override
   public Object getKeyForSizing() {
+
+
+
+
     // inline keys always report null for sizing since the size comes from the entry size
     return null;
+
   }
 
+
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   // stats code
   @Override
-  public final void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(boolean hit, long time) {
     setLastAccessed(time);
     if (hit) {
       incrementHitCount();
@@ -302,79 +329,82 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
       incrementMissCount();
     }
   }
-
   @Override
-  protected final void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
     _setLastModified(lastModified);
-    if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
+    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");
-
+  
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapIntKey> hitCountUpdater 
+    = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapIntKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapIntKey> missCountUpdater 
+    = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapIntKey.class, "missCount");
+  
   @Override
-  public final long getLastAccessed() throws InternalStatisticsDisabledException {
+  public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
-
   private void setLastAccessed(long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
-
   @Override
-  public final long getHitCount() throws InternalStatisticsDisabledException {
+  public long getHitCount() throws InternalStatisticsDisabledException {
     return this.hitCount & 0xFFFFFFFFL;
   }
-
   @Override
-  public final long getMissCount() throws InternalStatisticsDisabledException {
+  public long getMissCount() throws InternalStatisticsDisabledException {
     return this.missCount & 0xFFFFFFFFL;
   }
-
   private void incrementHitCount() {
     hitCountUpdater.incrementAndGet(this);
   }
-
   private void incrementMissCount() {
     missCountUpdater.incrementAndGet(this);
   }
-
   @Override
-  public final void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+  public void resetCounts() throws InternalStatisticsDisabledException {
+    hitCountUpdater.set(this,0);
+    missCountUpdater.set(this,0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   @Override
-  public final void txDidDestroy(long currTime) {
+  public void txDidDestroy(long currTime) {
     setLastModified(currTime);
     setLastAccessed(currTime);
     this.hitCount = 0;
     this.missCount = 0;
   }
-
   @Override
   public boolean hasStats() {
     return true;
   }
 
+  
+
+  
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   // key code
-  private final int key;
 
+
+
+
+
+
+
+
+  private final int key;
   @Override
-  public final Object getKey() {
+  public Object getKey() {
     return this.key;
   }
-
   @Override
   public boolean isKeyEqual(Object k) {
     if (k instanceof Integer) {
@@ -382,5 +412,8 @@ public class VMStatsDiskLRURegionEntryHeapIntKey extends VMStatsDiskLRURegionEnt
     }
     return false;
   }
+  
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
 }
+

http://git-wip-us.apache.org/repos/asf/geode/blob/30f455bb/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapLongKey.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapLongKey.java
index d65ea70..67bf7d4 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapLongKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapLongKey.java
@@ -15,55 +15,96 @@
 package org.apache.geode.internal.cache;
 
 // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+
+
+
+
+
+
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+
+
+
+
 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.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
+// disk: 1
+// lru: 1
+// stats: 1
 // 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 long: 1
 // 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) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
+  public VMStatsDiskLRURegionEntryHeapLongKey  (RegionEntryContext context, long key, 
+
+
+
+      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
   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;
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapLongKey> lastModifiedUpdater
+    = AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapLongKey.class, "lastModified");
 
+  private volatile Object value;
   @Override
-  protected final Object getValueField() {
+  protected Object getValueField() {
     return this.value;
   }
-
   @Override
   protected void setValueField(Object v) {
     this.value = v;
@@ -72,42 +113,40 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
   protected long getLastModifiedField() {
     return lastModifiedUpdater.get(this);
   }
-
   protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
     return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
   }
-
   /**
    * @see HashEntry#getEntryHash()
    */
-  public final int getEntryHash() {
+  public int getEntryHash() {
     return this.hash;
   }
-
   protected void setEntryHash(int v) {
     this.hash = v;
   }
-
   /**
    * @see HashEntry#getNextEntry()
    */
-  public final HashEntry<Object, Object> getNextEntry() {
+  public HashEntry<Object, Object> getNextEntry() {
     return this.next;
   }
-
   /**
    * @see HashEntry#setNextEntry
    */
-  public final void setNextEntry(final HashEntry<Object, Object> n) {
+  public void setNextEntry(final HashEntry<Object, Object> n) {
     this.next = n;
   }
 
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   // disk code
+
   protected void initialize(RegionEntryContext drs, Object value) {
     boolean isBackup;
     if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
+      isBackup = ((LocalRegion)drs).getDiskRegion().isBackup();
     } else if (drs instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
@@ -118,22 +157,23 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
       diskInitialize(drs, value);
     }
   }
-
   @Override
-  public final synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(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;
   }
 
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
+    DiskRecoveryStore drs = (DiskRecoveryStore)context;
     DiskStoreImpl ds = drs.getDiskStore();
     long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
+    //get appropriate instance of DiskId implementation based on maxOplogSize
     this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
     Helper.initialize(this, drs, value);
   }
@@ -143,158 +183,147 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
    * 
    * @since GemFire 5.1
    */
-  protected DiskId id;// = new DiskId();
-
+  protected DiskId id;//= new DiskId();
   public DiskId getDiskId() {
     return this.id;
   }
-
   @Override
   void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
-  }
-
-  // // inlining DiskId
-  // // always have these fields
-  // /**
-  // * id consists of
-  // * most significant
-  // * 1 byte = users bits
-  // * 2-8 bytes = oplog id
-  // * least significant.
-  // *
-  // * The highest bit in the oplog id part is set to 1 if the oplog id
-  // * is negative.
-  // * @todo this field could be an int for an overflow only region
-  // */
-  // private long id;
-  // /**
-  // * Length of the bytes on disk.
-  // * This is always set. If the value is invalid then it will be set to 0.
-  // * The most significant bit is used by overflow to mark it as needing to be written.
-  // */
-  // protected int valueLength = 0;
-  // // have intOffset or longOffset
-  // // intOffset
-  // /**
-  // * The position in the oplog (the oplog offset) where this entry's value is
-  // * stored
-  // */
-  // private volatile int offsetInOplog;
-  // // longOffset
-  // /**
-  // * The position in the oplog (the oplog offset) where this entry's value is
-  // * stored
-  // */
-  // private volatile long offsetInOplog;
-  // // have overflowOnly or persistence
-  // // overflowOnly
-  // // no fields
-  // // persistent
-  // /** unique entry identifier * */
-  // private long keyId;
+    this.id = ((AbstractDiskRegionEntry)old).getDiskId();
+  }
+//  // inlining DiskId
+//  // always have these fields
+//  /**
+//   * id consists of
+//   * most significant
+//   * 1 byte = users bits
+//   * 2-8 bytes = oplog id
+//   * least significant.
+//   * 
+//   * The highest bit in the oplog id part is set to 1 if the oplog id
+//   * is negative.
+//   * @todo this field could be an int for an overflow only region
+//   */
+//  private long id;
+//  /**
+//   * Length of the bytes on disk.
+//   * This is always set. If the value is invalid then it will be set to 0.
+//   * The most significant bit is used by overflow to mark it as needing to be written.
+//   */
+//  protected int valueLength = 0;
+//  // have intOffset or longOffset
+//  // intOffset
+//  /**
+//   * The position in the oplog (the oplog offset) where this entry's value is
+//   * stored
+//   */
+//  private volatile int offsetInOplog;
+//  // longOffset
+//  /**
+//   * The position in the oplog (the oplog offset) where this entry's value is
+//   * stored
+//   */
+//  private volatile long offsetInOplog;
+//  // have overflowOnly or persistence
+//  // overflowOnly
+//  // no fields
+//  // persistent
+//  /** unique entry identifier * */
+//  private long keyId;
+
+  
+
   // 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 final 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
-  }
 
+
+  }
+  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
+  }
+  
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public final synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  
+  public synchronized int updateEntrySize(EnableLRU capacityController,
+                                                Object value) {
     int oldSize = getEntrySize();
-    int newSize = capacityController.entrySize(getKeyForSizing(), value);
+    int newSize = capacityController.entrySize( getKeyForSizing(), value);
     setEntrySize(newSize);
     int delta = newSize - oldSize;
-    // if ( debug ) log( "updateEntrySize key=" + getKey()
-    // + (_getValue() == Token.INVALID ? " invalid" :
-    // (_getValue() == Token.LOCAL_INVALID ? "local_invalid" :
-    // (_getValue()==null ? " evicted" : " valid")))
-    // + " oldSize=" + oldSize
-    // + " newSize=" + this.size );
     return delta;
   }
-
-  public final boolean testRecentlyUsed() {
+  public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
-
   @Override
-  public final void setRecentlyUsed() {
+  public void setRecentlyUsed() {
     setBits(RECENTLY_USED);
   }
-
-  public final void unsetRecentlyUsed() {
+  public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
-
-  public final boolean testEvicted() {
+  public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
-
-  public final void setEvicted() {
+  public void setEvicted() {
     setBits(EVICTED);
   }
-
-  public final void unsetEvicted() {
+  public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+
   private LRUClockNode nextLRU;
   private LRUClockNode prevLRU;
   private int size;
-
-  public final void setNextLRUNode(LRUClockNode next) {
+  public void setNextLRUNode( LRUClockNode next ) {
     this.nextLRU = next;
   }
-
-  public final LRUClockNode nextLRUNode() {
+  public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
-
-  public final void setPrevLRUNode(LRUClockNode prev) {
+  public void setPrevLRUNode( LRUClockNode prev ) {
     this.prevLRU = prev;
   }
-
-  public final LRUClockNode prevLRUNode() {
+  public LRUClockNode prevLRUNode() {
     return this.prevLRU;
   }
-
-  public final int getEntrySize() {
+  public int getEntrySize() {
     return this.size;
   }
-
-  protected final void setEntrySize(int size) {
+  protected void setEntrySize(int size) {
     this.size = size;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // @Override
-  // public StringBuilder appendFieldsToString(final StringBuilder sb) {
-  // StringBuilder result = super.appendFieldsToString(sb);
-  // result.append("; prev=").append(this.prevLRU==null?"null":"not null");
-  // result.append("; next=").append(this.nextLRU==null?"null":"not null");
-  // return result;
-  // }
+  
   @Override
   public Object getKeyForSizing() {
+
+
+
+
     // inline keys always report null for sizing since the size comes from the entry size
     return null;
+
   }
 
+
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   // stats code
   @Override
-  public final void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(boolean hit, long time) {
     setLastAccessed(time);
     if (hit) {
       incrementHitCount();
@@ -302,79 +331,75 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
       incrementMissCount();
     }
   }
-
   @Override
-  protected final void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
     _setLastModified(lastModified);
-    if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
+    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");
-
+  
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapLongKey> hitCountUpdater 
+    = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapLongKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapLongKey> missCountUpdater 
+    = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapLongKey.class, "missCount");
+  
   @Override
-  public final long getLastAccessed() throws InternalStatisticsDisabledException {
+  public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
-
   private void setLastAccessed(long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
-
   @Override
-  public final long getHitCount() throws InternalStatisticsDisabledException {
+  public long getHitCount() throws InternalStatisticsDisabledException {
     return this.hitCount & 0xFFFFFFFFL;
   }
-
   @Override
-  public final long getMissCount() throws InternalStatisticsDisabledException {
+  public long getMissCount() throws InternalStatisticsDisabledException {
     return this.missCount & 0xFFFFFFFFL;
   }
-
   private void incrementHitCount() {
     hitCountUpdater.incrementAndGet(this);
   }
-
   private void incrementMissCount() {
     missCountUpdater.incrementAndGet(this);
   }
-
   @Override
-  public final void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+  public void resetCounts() throws InternalStatisticsDisabledException {
+    hitCountUpdater.set(this,0);
+    missCountUpdater.set(this,0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   @Override
-  public final void txDidDestroy(long currTime) {
+  public void txDidDestroy(long currTime) {
     setLastModified(currTime);
     setLastAccessed(currTime);
     this.hitCount = 0;
     this.missCount = 0;
   }
-
   @Override
   public boolean hasStats() {
     return true;
   }
 
+  
+
+  
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   // key code
-  private final long key;
 
+  private final long key;
   @Override
-  public final Object getKey() {
+  public Object getKey() {
     return this.key;
   }
-
   @Override
   public boolean isKeyEqual(Object k) {
     if (k instanceof Long) {
@@ -382,5 +407,8 @@ public class VMStatsDiskLRURegionEntryHeapLongKey extends VMStatsDiskLRURegionEn
     }
     return false;
   }
+  
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
 }
+

http://git-wip-us.apache.org/repos/asf/geode/blob/30f455bb/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapObjectKey.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapObjectKey.java
index cbfa0f8..d5ecb01 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapObjectKey.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapObjectKey.java
@@ -15,57 +15,92 @@
 package org.apache.geode.internal.cache;
 
 // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+
+
+
+
+
+
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+
+
+
+
 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.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
+// disk: 1
+// lru: 1
+// stats: 1
 // versioned: VERSIONED
 // offheap: OFFHEAP
 // One of the following key macros must be defined:
-// key object: KEY_OBJECT
+// key object: 1
 // 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) {
-    super(context, (value instanceof RecoveredEntry ? null : value));
+  public VMStatsDiskLRURegionEntryHeapObjectKey  (RegionEntryContext context, Object key, 
+
+
+
+      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
   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;
+  private static final AtomicLongFieldUpdater<VMStatsDiskLRURegionEntryHeapObjectKey> lastModifiedUpdater
+    = AtomicLongFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapObjectKey.class, "lastModified");
 
+  private volatile Object value;
   @Override
-  protected final Object getValueField() {
+  protected Object getValueField() {
     return this.value;
   }
-
   @Override
   protected void setValueField(Object v) {
     this.value = v;
@@ -74,42 +109,40 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
   protected long getLastModifiedField() {
     return lastModifiedUpdater.get(this);
   }
-
   protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
     return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
   }
-
   /**
    * @see HashEntry#getEntryHash()
    */
-  public final int getEntryHash() {
+  public int getEntryHash() {
     return this.hash;
   }
-
   protected void setEntryHash(int v) {
     this.hash = v;
   }
-
   /**
    * @see HashEntry#getNextEntry()
    */
-  public final HashEntry<Object, Object> getNextEntry() {
+  public HashEntry<Object, Object> getNextEntry() {
     return this.next;
   }
-
   /**
    * @see HashEntry#setNextEntry
    */
-  public final void setNextEntry(final HashEntry<Object, Object> n) {
+  public void setNextEntry(final HashEntry<Object, Object> n) {
     this.next = n;
   }
 
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   // disk code
+
   protected void initialize(RegionEntryContext drs, Object value) {
     boolean isBackup;
     if (drs instanceof LocalRegion) {
-      isBackup = ((LocalRegion) drs).getDiskRegion().isBackup();
+      isBackup = ((LocalRegion)drs).getDiskRegion().isBackup();
     } else if (drs instanceof PlaceHolderDiskRegion) {
       isBackup = true;
     } else {
@@ -120,22 +153,23 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
       diskInitialize(drs, value);
     }
   }
-
   @Override
-  public final synchronized int updateAsyncEntrySize(EnableLRU capacityController) {
+  public synchronized int updateAsyncEntrySize(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;
   }
 
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   private void diskInitialize(RegionEntryContext context, Object value) {
-    DiskRecoveryStore drs = (DiskRecoveryStore) context;
+    DiskRecoveryStore drs = (DiskRecoveryStore)context;
     DiskStoreImpl ds = drs.getDiskStore();
     long maxOplogSize = ds.getMaxOplogSize();
-    // get appropriate instance of DiskId implementation based on maxOplogSize
+    //get appropriate instance of DiskId implementation based on maxOplogSize
     this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList());
     Helper.initialize(this, drs, value);
   }
@@ -145,158 +179,147 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
    * 
    * @since GemFire 5.1
    */
-  protected DiskId id;// = new DiskId();
-
+  protected DiskId id;//= new DiskId();
   public DiskId getDiskId() {
     return this.id;
   }
-
   @Override
   void setDiskId(RegionEntry old) {
-    this.id = ((AbstractDiskRegionEntry) old).getDiskId();
-  }
-
-  // // inlining DiskId
-  // // always have these fields
-  // /**
-  // * id consists of
-  // * most significant
-  // * 1 byte = users bits
-  // * 2-8 bytes = oplog id
-  // * least significant.
-  // *
-  // * The highest bit in the oplog id part is set to 1 if the oplog id
-  // * is negative.
-  // * @todo this field could be an int for an overflow only region
-  // */
-  // private long id;
-  // /**
-  // * Length of the bytes on disk.
-  // * This is always set. If the value is invalid then it will be set to 0.
-  // * The most significant bit is used by overflow to mark it as needing to be written.
-  // */
-  // protected int valueLength = 0;
-  // // have intOffset or longOffset
-  // // intOffset
-  // /**
-  // * The position in the oplog (the oplog offset) where this entry's value is
-  // * stored
-  // */
-  // private volatile int offsetInOplog;
-  // // longOffset
-  // /**
-  // * The position in the oplog (the oplog offset) where this entry's value is
-  // * stored
-  // */
-  // private volatile long offsetInOplog;
-  // // have overflowOnly or persistence
-  // // overflowOnly
-  // // no fields
-  // // persistent
-  // /** unique entry identifier * */
-  // private long keyId;
+    this.id = ((AbstractDiskRegionEntry)old).getDiskId();
+  }
+//  // inlining DiskId
+//  // always have these fields
+//  /**
+//   * id consists of
+//   * most significant
+//   * 1 byte = users bits
+//   * 2-8 bytes = oplog id
+//   * least significant.
+//   * 
+//   * The highest bit in the oplog id part is set to 1 if the oplog id
+//   * is negative.
+//   * @todo this field could be an int for an overflow only region
+//   */
+//  private long id;
+//  /**
+//   * Length of the bytes on disk.
+//   * This is always set. If the value is invalid then it will be set to 0.
+//   * The most significant bit is used by overflow to mark it as needing to be written.
+//   */
+//  protected int valueLength = 0;
+//  // have intOffset or longOffset
+//  // intOffset
+//  /**
+//   * The position in the oplog (the oplog offset) where this entry's value is
+//   * stored
+//   */
+//  private volatile int offsetInOplog;
+//  // longOffset
+//  /**
+//   * The position in the oplog (the oplog offset) where this entry's value is
+//   * stored
+//   */
+//  private volatile long offsetInOplog;
+//  // have overflowOnly or persistence
+//  // overflowOnly
+//  // no fields
+//  // persistent
+//  /** unique entry identifier * */
+//  private long keyId;
+
+  
+
   // 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 final 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
-  }
 
+
+  }
+  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
+  }
+  
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  public final synchronized int updateEntrySize(EnableLRU capacityController, Object value) {
+  
+  public synchronized int updateEntrySize(EnableLRU capacityController,
+                                                Object value) {
     int oldSize = getEntrySize();
-    int newSize = capacityController.entrySize(getKeyForSizing(), value);
+    int newSize = capacityController.entrySize( getKeyForSizing(), value);
     setEntrySize(newSize);
     int delta = newSize - oldSize;
-    // if ( debug ) log( "updateEntrySize key=" + getKey()
-    // + (_getValue() == Token.INVALID ? " invalid" :
-    // (_getValue() == Token.LOCAL_INVALID ? "local_invalid" :
-    // (_getValue()==null ? " evicted" : " valid")))
-    // + " oldSize=" + oldSize
-    // + " newSize=" + this.size );
     return delta;
   }
-
-  public final boolean testRecentlyUsed() {
+  public boolean testRecentlyUsed() {
     return areAnyBitsSet(RECENTLY_USED);
   }
-
   @Override
-  public final void setRecentlyUsed() {
+  public void setRecentlyUsed() {
     setBits(RECENTLY_USED);
   }
-
-  public final void unsetRecentlyUsed() {
+  public void unsetRecentlyUsed() {
     clearBits(~RECENTLY_USED);
   }
-
-  public final boolean testEvicted() {
+  public boolean testEvicted() {
     return areAnyBitsSet(EVICTED);
   }
-
-  public final void setEvicted() {
+  public void setEvicted() {
     setBits(EVICTED);
   }
-
-  public final void unsetEvicted() {
+  public void unsetEvicted() {
     clearBits(~EVICTED);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+
   private LRUClockNode nextLRU;
   private LRUClockNode prevLRU;
   private int size;
-
-  public final void setNextLRUNode(LRUClockNode next) {
+  public void setNextLRUNode( LRUClockNode next ) {
     this.nextLRU = next;
   }
-
-  public final LRUClockNode nextLRUNode() {
+  public LRUClockNode nextLRUNode() {
     return this.nextLRU;
   }
-
-  public final void setPrevLRUNode(LRUClockNode prev) {
+  public void setPrevLRUNode( LRUClockNode prev ) {
     this.prevLRU = prev;
   }
-
-  public final LRUClockNode prevLRUNode() {
+  public LRUClockNode prevLRUNode() {
     return this.prevLRU;
   }
-
-  public final int getEntrySize() {
+  public int getEntrySize() {
     return this.size;
   }
-
-  protected final void setEntrySize(int size) {
+  protected void setEntrySize(int size) {
     this.size = size;
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
-  // @Override
-  // public StringBuilder appendFieldsToString(final StringBuilder sb) {
-  // StringBuilder result = super.appendFieldsToString(sb);
-  // result.append("; prev=").append(this.prevLRU==null?"null":"not null");
-  // result.append("; next=").append(this.nextLRU==null?"null":"not null");
-  // return result;
-  // }
+  
   @Override
   public Object getKeyForSizing() {
+
     // default implementation.
     return getKey();
+
+
+
+
   }
 
+
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   // stats code
   @Override
-  public final void updateStatsForGet(boolean hit, long time) {
+  public void updateStatsForGet(boolean hit, long time) {
     setLastAccessed(time);
     if (hit) {
       incrementHitCount();
@@ -304,79 +327,77 @@ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegion
       incrementMissCount();
     }
   }
-
   @Override
-  protected final void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
+  protected void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) {
     _setLastModified(lastModified);
-    if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) {
+    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");
-
+  
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapObjectKey> hitCountUpdater 
+    = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapObjectKey.class, "hitCount");
+  private static final AtomicIntegerFieldUpdater<VMStatsDiskLRURegionEntryHeapObjectKey> missCountUpdater 
+    = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskLRURegionEntryHeapObjectKey.class, "missCount");
+  
   @Override
-  public final long getLastAccessed() throws InternalStatisticsDisabledException {
+  public long getLastAccessed() throws InternalStatisticsDisabledException {
     return this.lastAccessed;
   }
-
   private void setLastAccessed(long lastAccessed) {
     this.lastAccessed = lastAccessed;
   }
-
   @Override
-  public final long getHitCount() throws InternalStatisticsDisabledException {
+  public long getHitCount() throws InternalStatisticsDisabledException {
     return this.hitCount & 0xFFFFFFFFL;
   }
-
   @Override
-  public final long getMissCount() throws InternalStatisticsDisabledException {
+  public long getMissCount() throws InternalStatisticsDisabledException {
     return this.missCount & 0xFFFFFFFFL;
   }
-
   private void incrementHitCount() {
     hitCountUpdater.incrementAndGet(this);
   }
-
   private void incrementMissCount() {
     missCountUpdater.incrementAndGet(this);
   }
-
   @Override
-  public final void resetCounts() throws InternalStatisticsDisabledException {
-    hitCountUpdater.set(this, 0);
-    missCountUpdater.set(this, 0);
+  public void resetCounts() throws InternalStatisticsDisabledException {
+    hitCountUpdater.set(this,0);
+    missCountUpdater.set(this,0);
   }
 
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   @Override
-  public final void txDidDestroy(long currTime) {
+  public void txDidDestroy(long currTime) {
     setLastModified(currTime);
     setLastAccessed(currTime);
     this.hitCount = 0;
     this.missCount = 0;
   }
-
   @Override
   public boolean hasStats() {
     return true;
   }
 
+  
+
+  
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
+  
   // key code
-  private final Object key;
 
+  private final Object key;
   @Override
-  public final Object getKey() {
+  public Object getKey() {
     return this.key;
   }
+
+
   // DO NOT modify this class. It was generated from LeafRegionEntry.cpp
 }
+


Mime
View raw message