GEODE-1785: add script to generate region entry source Added generateRegionEntryClasses.sh and LeafRegionEntry.cpp. To modify the leaf subclasses of AbstractRegionEntry edit LeafeRegionEntry.cpp, run dev-tools/generatedRegionEntryClasses.sh, and then do a gradlew spotlessApply since the generated code needs to be formatted.
Project: http://git-wip-us.apache.org/repos/asf/incubator-geode/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-geode/commit/df2f0c96 Tree: http://git-wip-us.apache.org/repos/asf/incubator-geode/tree/df2f0c96 Diff: http://git-wip-us.apache.org/repos/asf/incubator-geode/diff/df2f0c96 Branch: refs/heads/feature/GEODE-1930 Commit: df2f0c964d4fe62fa12b69266747deeccef3aac5 Parents: 88e5d0f Author: Darrel Schneider <dschnei...@pivotal.io> Authored: Wed Nov 9 14:34:33 2016 -0800 Committer: Darrel Schneider <dschnei...@pivotal.io> Committed: Thu Nov 10 10:16:01 2016 -0800 ---------------------------------------------------------------------- dev-tools/generateRegionEntryClasses.sh | 64 ++ .../geode/internal/cache/LeafRegionEntry.cpp | 866 +++++++++++++++++++ .../VMStatsDiskLRURegionEntryHeapIntKey.java | 2 +- .../VMStatsDiskLRURegionEntryHeapLongKey.java | 2 +- .../VMStatsDiskLRURegionEntryHeapObjectKey.java | 2 +- ...VMStatsDiskLRURegionEntryHeapStringKey1.java | 2 +- ...VMStatsDiskLRURegionEntryHeapStringKey2.java | 2 +- .../VMStatsDiskLRURegionEntryHeapUUIDKey.java | 2 +- .../VMStatsDiskLRURegionEntryOffHeapIntKey.java | 2 +- ...VMStatsDiskLRURegionEntryOffHeapLongKey.java | 2 +- ...StatsDiskLRURegionEntryOffHeapObjectKey.java | 2 +- ...tatsDiskLRURegionEntryOffHeapStringKey1.java | 2 +- ...tatsDiskLRURegionEntryOffHeapStringKey2.java | 2 +- ...VMStatsDiskLRURegionEntryOffHeapUUIDKey.java | 2 +- .../cache/VMStatsDiskRegionEntryHeapIntKey.java | 2 +- .../VMStatsDiskRegionEntryHeapLongKey.java | 2 +- .../VMStatsDiskRegionEntryHeapObjectKey.java | 2 +- .../VMStatsDiskRegionEntryHeapStringKey1.java | 2 +- .../VMStatsDiskRegionEntryHeapStringKey2.java | 2 +- .../VMStatsDiskRegionEntryHeapUUIDKey.java | 2 +- .../VMStatsDiskRegionEntryOffHeapIntKey.java | 2 +- .../VMStatsDiskRegionEntryOffHeapLongKey.java | 2 +- .../VMStatsDiskRegionEntryOffHeapObjectKey.java | 2 +- ...VMStatsDiskRegionEntryOffHeapStringKey1.java | 2 +- ...VMStatsDiskRegionEntryOffHeapStringKey2.java | 2 +- .../VMStatsDiskRegionEntryOffHeapUUIDKey.java | 2 +- .../cache/VMStatsLRURegionEntryHeapIntKey.java | 2 +- .../cache/VMStatsLRURegionEntryHeapLongKey.java | 2 +- .../VMStatsLRURegionEntryHeapObjectKey.java | 2 +- .../VMStatsLRURegionEntryHeapStringKey1.java | 2 +- .../VMStatsLRURegionEntryHeapStringKey2.java | 2 +- .../cache/VMStatsLRURegionEntryHeapUUIDKey.java | 2 +- .../VMStatsLRURegionEntryOffHeapIntKey.java | 2 +- .../VMStatsLRURegionEntryOffHeapLongKey.java | 2 +- .../VMStatsLRURegionEntryOffHeapObjectKey.java | 2 +- .../VMStatsLRURegionEntryOffHeapStringKey1.java | 2 +- .../VMStatsLRURegionEntryOffHeapStringKey2.java | 2 +- .../VMStatsLRURegionEntryOffHeapUUIDKey.java | 2 +- .../cache/VMStatsRegionEntryHeapIntKey.java | 2 +- .../cache/VMStatsRegionEntryHeapLongKey.java | 2 +- .../cache/VMStatsRegionEntryHeapObjectKey.java | 2 +- .../cache/VMStatsRegionEntryHeapStringKey1.java | 2 +- .../cache/VMStatsRegionEntryHeapStringKey2.java | 2 +- .../cache/VMStatsRegionEntryHeapUUIDKey.java | 2 +- .../cache/VMStatsRegionEntryOffHeapIntKey.java | 2 +- .../cache/VMStatsRegionEntryOffHeapLongKey.java | 2 +- .../VMStatsRegionEntryOffHeapObjectKey.java | 2 +- .../VMStatsRegionEntryOffHeapStringKey1.java | 2 +- .../VMStatsRegionEntryOffHeapStringKey2.java | 2 +- .../cache/VMStatsRegionEntryOffHeapUUIDKey.java | 2 +- .../VMThinDiskLRURegionEntryHeapIntKey.java | 2 +- .../VMThinDiskLRURegionEntryHeapLongKey.java | 2 +- .../VMThinDiskLRURegionEntryHeapObjectKey.java | 2 +- .../VMThinDiskLRURegionEntryHeapStringKey1.java | 2 +- .../VMThinDiskLRURegionEntryHeapStringKey2.java | 2 +- .../VMThinDiskLRURegionEntryHeapUUIDKey.java | 2 +- .../VMThinDiskLRURegionEntryOffHeapIntKey.java | 2 +- .../VMThinDiskLRURegionEntryOffHeapLongKey.java | 2 +- ...MThinDiskLRURegionEntryOffHeapObjectKey.java | 2 +- ...ThinDiskLRURegionEntryOffHeapStringKey1.java | 2 +- ...ThinDiskLRURegionEntryOffHeapStringKey2.java | 2 +- .../VMThinDiskLRURegionEntryOffHeapUUIDKey.java | 2 +- .../cache/VMThinDiskRegionEntryHeapIntKey.java | 2 +- .../cache/VMThinDiskRegionEntryHeapLongKey.java | 2 +- .../VMThinDiskRegionEntryHeapObjectKey.java | 2 +- .../VMThinDiskRegionEntryHeapStringKey1.java | 2 +- .../VMThinDiskRegionEntryHeapStringKey2.java | 2 +- .../cache/VMThinDiskRegionEntryHeapUUIDKey.java | 2 +- .../VMThinDiskRegionEntryOffHeapIntKey.java | 2 +- .../VMThinDiskRegionEntryOffHeapLongKey.java | 2 +- .../VMThinDiskRegionEntryOffHeapObjectKey.java | 2 +- .../VMThinDiskRegionEntryOffHeapStringKey1.java | 2 +- .../VMThinDiskRegionEntryOffHeapStringKey2.java | 2 +- .../VMThinDiskRegionEntryOffHeapUUIDKey.java | 2 +- .../cache/VMThinLRURegionEntryHeapIntKey.java | 2 +- .../cache/VMThinLRURegionEntryHeapLongKey.java | 2 +- .../VMThinLRURegionEntryHeapObjectKey.java | 2 +- .../VMThinLRURegionEntryHeapStringKey1.java | 2 +- .../VMThinLRURegionEntryHeapStringKey2.java | 2 +- .../cache/VMThinLRURegionEntryHeapUUIDKey.java | 2 +- .../VMThinLRURegionEntryOffHeapIntKey.java | 2 +- .../VMThinLRURegionEntryOffHeapLongKey.java | 2 +- .../VMThinLRURegionEntryOffHeapObjectKey.java | 2 +- .../VMThinLRURegionEntryOffHeapStringKey1.java | 2 +- .../VMThinLRURegionEntryOffHeapStringKey2.java | 2 +- .../VMThinLRURegionEntryOffHeapUUIDKey.java | 2 +- .../cache/VMThinRegionEntryHeapIntKey.java | 2 +- .../cache/VMThinRegionEntryHeapLongKey.java | 2 +- .../cache/VMThinRegionEntryHeapObjectKey.java | 2 +- .../cache/VMThinRegionEntryHeapStringKey1.java | 2 +- .../cache/VMThinRegionEntryHeapStringKey2.java | 2 +- .../cache/VMThinRegionEntryHeapUUIDKey.java | 2 +- .../cache/VMThinRegionEntryOffHeapIntKey.java | 2 +- .../cache/VMThinRegionEntryOffHeapLongKey.java | 2 +- .../VMThinRegionEntryOffHeapObjectKey.java | 2 +- .../VMThinRegionEntryOffHeapStringKey1.java | 2 +- .../VMThinRegionEntryOffHeapStringKey2.java | 2 +- .../cache/VMThinRegionEntryOffHeapUUIDKey.java | 2 +- ...sionedStatsDiskLRURegionEntryHeapIntKey.java | 2 +- ...ionedStatsDiskLRURegionEntryHeapLongKey.java | 2 +- ...nedStatsDiskLRURegionEntryHeapObjectKey.java | 2 +- ...edStatsDiskLRURegionEntryHeapStringKey1.java | 2 +- ...edStatsDiskLRURegionEntryHeapStringKey2.java | 2 +- ...ionedStatsDiskLRURegionEntryHeapUUIDKey.java | 2 +- ...nedStatsDiskLRURegionEntryOffHeapIntKey.java | 2 +- ...edStatsDiskLRURegionEntryOffHeapLongKey.java | 2 +- ...StatsDiskLRURegionEntryOffHeapObjectKey.java | 2 +- ...tatsDiskLRURegionEntryOffHeapStringKey1.java | 2 +- ...tatsDiskLRURegionEntryOffHeapStringKey2.java | 2 +- ...edStatsDiskLRURegionEntryOffHeapUUIDKey.java | 2 +- ...VersionedStatsDiskRegionEntryHeapIntKey.java | 2 +- ...ersionedStatsDiskRegionEntryHeapLongKey.java | 2 +- ...sionedStatsDiskRegionEntryHeapObjectKey.java | 2 +- ...ionedStatsDiskRegionEntryHeapStringKey1.java | 2 +- ...ionedStatsDiskRegionEntryHeapStringKey2.java | 2 +- ...ersionedStatsDiskRegionEntryHeapUUIDKey.java | 2 +- ...sionedStatsDiskRegionEntryOffHeapIntKey.java | 2 +- ...ionedStatsDiskRegionEntryOffHeapLongKey.java | 2 +- ...nedStatsDiskRegionEntryOffHeapObjectKey.java | 2 +- ...edStatsDiskRegionEntryOffHeapStringKey1.java | 2 +- ...edStatsDiskRegionEntryOffHeapStringKey2.java | 2 +- ...ionedStatsDiskRegionEntryOffHeapUUIDKey.java | 2 +- .../VersionedStatsLRURegionEntryHeapIntKey.java | 2 +- ...VersionedStatsLRURegionEntryHeapLongKey.java | 2 +- ...rsionedStatsLRURegionEntryHeapObjectKey.java | 2 +- ...sionedStatsLRURegionEntryHeapStringKey1.java | 2 +- ...sionedStatsLRURegionEntryHeapStringKey2.java | 2 +- ...VersionedStatsLRURegionEntryHeapUUIDKey.java | 2 +- ...rsionedStatsLRURegionEntryOffHeapIntKey.java | 2 +- ...sionedStatsLRURegionEntryOffHeapLongKey.java | 2 +- ...onedStatsLRURegionEntryOffHeapObjectKey.java | 2 +- ...nedStatsLRURegionEntryOffHeapStringKey1.java | 2 +- ...nedStatsLRURegionEntryOffHeapStringKey2.java | 2 +- ...sionedStatsLRURegionEntryOffHeapUUIDKey.java | 2 +- .../VersionedStatsRegionEntryHeapIntKey.java | 2 +- .../VersionedStatsRegionEntryHeapLongKey.java | 2 +- .../VersionedStatsRegionEntryHeapObjectKey.java | 2 +- ...VersionedStatsRegionEntryHeapStringKey1.java | 2 +- ...VersionedStatsRegionEntryHeapStringKey2.java | 2 +- .../VersionedStatsRegionEntryHeapUUIDKey.java | 2 +- .../VersionedStatsRegionEntryOffHeapIntKey.java | 2 +- ...VersionedStatsRegionEntryOffHeapLongKey.java | 2 +- ...rsionedStatsRegionEntryOffHeapObjectKey.java | 2 +- ...sionedStatsRegionEntryOffHeapStringKey1.java | 2 +- ...sionedStatsRegionEntryOffHeapStringKey2.java | 2 +- ...VersionedStatsRegionEntryOffHeapUUIDKey.java | 2 +- ...rsionedThinDiskLRURegionEntryHeapIntKey.java | 2 +- ...sionedThinDiskLRURegionEntryHeapLongKey.java | 2 +- ...onedThinDiskLRURegionEntryHeapObjectKey.java | 2 +- ...nedThinDiskLRURegionEntryHeapStringKey1.java | 2 +- ...nedThinDiskLRURegionEntryHeapStringKey2.java | 2 +- ...sionedThinDiskLRURegionEntryHeapUUIDKey.java | 2 +- ...onedThinDiskLRURegionEntryOffHeapIntKey.java | 2 +- ...nedThinDiskLRURegionEntryOffHeapLongKey.java | 2 +- ...dThinDiskLRURegionEntryOffHeapObjectKey.java | 2 +- ...ThinDiskLRURegionEntryOffHeapStringKey1.java | 2 +- ...ThinDiskLRURegionEntryOffHeapStringKey2.java | 2 +- ...nedThinDiskLRURegionEntryOffHeapUUIDKey.java | 2 +- .../VersionedThinDiskRegionEntryHeapIntKey.java | 2 +- ...VersionedThinDiskRegionEntryHeapLongKey.java | 2 +- ...rsionedThinDiskRegionEntryHeapObjectKey.java | 2 +- ...sionedThinDiskRegionEntryHeapStringKey1.java | 2 +- ...sionedThinDiskRegionEntryHeapStringKey2.java | 2 +- ...VersionedThinDiskRegionEntryHeapUUIDKey.java | 2 +- ...rsionedThinDiskRegionEntryOffHeapIntKey.java | 2 +- ...sionedThinDiskRegionEntryOffHeapLongKey.java | 2 +- ...onedThinDiskRegionEntryOffHeapObjectKey.java | 2 +- ...nedThinDiskRegionEntryOffHeapStringKey1.java | 2 +- ...nedThinDiskRegionEntryOffHeapStringKey2.java | 2 +- ...sionedThinDiskRegionEntryOffHeapUUIDKey.java | 2 +- .../VersionedThinLRURegionEntryHeapIntKey.java | 2 +- .../VersionedThinLRURegionEntryHeapLongKey.java | 2 +- ...ersionedThinLRURegionEntryHeapObjectKey.java | 2 +- ...rsionedThinLRURegionEntryHeapStringKey1.java | 2 +- ...rsionedThinLRURegionEntryHeapStringKey2.java | 2 +- .../VersionedThinLRURegionEntryHeapUUIDKey.java | 2 +- ...ersionedThinLRURegionEntryOffHeapIntKey.java | 2 +- ...rsionedThinLRURegionEntryOffHeapLongKey.java | 2 +- ...ionedThinLRURegionEntryOffHeapObjectKey.java | 2 +- ...onedThinLRURegionEntryOffHeapStringKey1.java | 2 +- ...onedThinLRURegionEntryOffHeapStringKey2.java | 2 +- ...rsionedThinLRURegionEntryOffHeapUUIDKey.java | 2 +- .../VersionedThinRegionEntryHeapIntKey.java | 2 +- .../VersionedThinRegionEntryHeapLongKey.java | 2 +- .../VersionedThinRegionEntryHeapObjectKey.java | 2 +- .../VersionedThinRegionEntryHeapStringKey1.java | 2 +- .../VersionedThinRegionEntryHeapStringKey2.java | 2 +- .../VersionedThinRegionEntryHeapUUIDKey.java | 2 +- .../VersionedThinRegionEntryOffHeapIntKey.java | 2 +- .../VersionedThinRegionEntryOffHeapLongKey.java | 2 +- ...ersionedThinRegionEntryOffHeapObjectKey.java | 2 +- ...rsionedThinRegionEntryOffHeapStringKey1.java | 2 +- ...rsionedThinRegionEntryOffHeapStringKey2.java | 2 +- .../VersionedThinRegionEntryOffHeapUUIDKey.java | 2 +- 194 files changed, 1122 insertions(+), 192 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/dev-tools/generateRegionEntryClasses.sh ---------------------------------------------------------------------- diff --git a/dev-tools/generateRegionEntryClasses.sh b/dev-tools/generateRegionEntryClasses.sh new file mode 100755 index 0000000..23a8a02 --- /dev/null +++ b/dev-tools/generateRegionEntryClasses.sh @@ -0,0 +1,64 @@ +#!/bin/bash +# Licensed to the Apache Software Foundation (ASF) under one or more contributor license +# agreements. See the NOTICE file distributed with this work for additional information regarding +# copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance with the License. You may obtain a +# copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software distributed under the License +# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +# or implied. See the License for the specific language governing permissions and limitations under +# the License. +# +# This script should only be run from the top level build directory +# (the one that contains the "dev-tools" subdirectory). +# It reads LeafRegionEntry.cpp, preprocesses it and generates all the leaf +# class source files that subclass AbstractRegionEntry. +# It executes cpp. It has been tested with gnu's cpp on linux. +# After using it to generate new java files, make sure and +# run './gradlew spotlessApply' to format these generated files. +# Then use 'git diff' to validate the changes you made to the +# generated java files before committing them. + +SRCDIR=geode-core/src/main/java/org/apache/geode/internal/cache +SRCFILE=$SRCDIR/LeafRegionEntry.cpp + +for VERTYPE in VM Versioned +do + for RETYPE in Thin Stats ThinLRU StatsLRU ThinDisk StatsDisk ThinDiskLRU StatsDiskLRU + do + for KEY_INFO in 'ObjectKey KEY_OBJECT' 'IntKey KEY_INT' 'LongKey KEY_LONG' 'UUIDKey KEY_UUID' 'StringKey1 KEY_STRING1' 'StringKey2 KEY_STRING2' + do + for MEMTYPE in Heap OffHeap + do + declare -a KEY_ARRAY=($KEY_INFO) + KEY_CLASS=${KEY_ARRAY[0]} + KEY_TYPE=${KEY_ARRAY[1]} + BASE=${VERTYPE}${RETYPE}RegionEntry${MEMTYPE} + OUT=${BASE}${KEY_CLASS} + WP_ARGS=-Wp,-C,-P,-D${KEY_TYPE},-DPARENT_CLASS=$BASE,-DLEAF_CLASS=$OUT + if [ "$VERTYPE" = "Versioned" ]; then + WP_ARGS=${WP_ARGS},-DVERSIONED + fi + if [[ "$RETYPE" = *Stats* ]]; then + WP_ARGS=${WP_ARGS},-DSTATS + fi + if [[ "$RETYPE" = *Disk* ]]; then + WP_ARGS=${WP_ARGS},-DDISK + fi + if [[ "$RETYPE" = *LRU* ]]; then + WP_ARGS=${WP_ARGS},-DLRU + fi + if [[ "$MEMTYPE" = "OffHeap" ]]; then + WP_ARGS=${WP_ARGS},-DOFFHEAP + fi + echo generating $SRCDIR/$OUT.java + cpp -E $WP_ARGS $SRCFILE >$SRCDIR/$OUT.java + #echo VERTYPE=$VERTYPE RETYPE=$RETYPE $KEY_INFO KEY_CLASS=$KEY_CLASS KEY_TYPE=$KEY_TYPE args=$WP_ARGS + done + done + done +done +echo now run \'./gradlew spotlessApply\' to format the generated files http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/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 new file mode 100644 index 0000000..b8122c3 --- /dev/null +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/LeafRegionEntry.cpp @@ -0,0 +1,866 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more contributor license + * agreements. See the NOTICE file distributed with this work for additional information regarding + * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance with the License. You may obtain a + * copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License + * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express + * or implied. See the License for the specific language governing permissions and limitations under + * the License. + */ +package org.apache.geode.internal.cache; + +// DO NOT modify this class. It was generated from LeafRegionEntry.cpp +#if defined(KEY_OBJECT) +#define KEY_TYPE Object +#elif defined(KEY_INT) +#define KEY_TYPE int +#elif defined(KEY_LONG) +#define KEY_TYPE long +#elif defined(KEY_UUID) +#define KEY_TYPE UUID +#elif defined(KEY_STRING1) || defined(KEY_STRING2) +#define KEY_TYPE String +#else +#error the KEY_TYPE macro must be defined +#endif + +#ifdef KEY_UUID +import java.util.UUID; +#endif +#if defined(STATS) || defined(LRU) +import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; +#endif +import java.util.concurrent.atomic.AtomicLongFieldUpdater; +#if defined(VERSIONED) +import org.apache.geode.cache.EntryEvent; +#endif +#if defined(DISK) || defined(LRU) +import org.apache.geode.internal.cache.lru.EnableLRU; +#endif +#ifdef DISK +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.lru.LRUClockNode; +import org.apache.geode.internal.cache.lru.NewLRUClockHand; +#endif +#ifdef VERSIONED +import org.apache.geode.distributed.internal.membership.InternalDistributedMember; +import org.apache.geode.internal.cache.versions.VersionSource; +import org.apache.geode.internal.cache.versions.VersionStamp; +import org.apache.geode.internal.cache.versions.VersionTag; +#endif +#ifdef OFFHEAP +import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper; +import org.apache.geode.internal.offheap.annotations.Released; +import org.apache.geode.internal.offheap.annotations.Retained; +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 + +/** + * 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, +#ifdef OFFHEAP + @Retained +#endif + Object value +#if defined(KEY_STRING1) || defined(KEY_STRING2) + , boolean byteEncode +#endif + ) { + super(context, +#ifdef DISK + (value instanceof RecoveredEntry ? null : value) +#else + value +#endif + ); + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +#ifdef DISK + initialize(context, value); +#endif +#if defined(KEY_OBJECT) + this.key = key; +#elif defined(KEY_INT) + this.key = key; +#elif defined(KEY_LONG) + this.key = key; +#elif defined(KEY_UUID) + this.keyMostSigBits = key.getMostSignificantBits(); + this.keyLeastSigBits = key.getLeastSignificantBits(); +#elif defined(KEY_STRING1) + // 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; +#elif defined(KEY_STRING2) + // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY + long tmpBits1 = 0L; + long tmpBits2 = 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; + } else { + tmpBits2 <<= 8; + tmpBits2 |= (byte)key.charAt(i) & 0xff; + } + } + tmpBits1 |= 1<<6; + } else { + for (int i=key.length()-1; i >= 0; i--) { + if (i < 3) { + tmpBits1 |= key.charAt(i); + tmpBits1 <<= 16; + } else { + tmpBits2 <<= 16; + tmpBits2 |= key.charAt(i); + } + } + } + tmpBits1 |= key.length(); + this.bits1 = tmpBits1; + this.bits2 = tmpBits2; +#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); + } + + @Override + protected Object getValueField() { + return OffHeapRegionEntryHelper._getValue(this); + } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override +#ifdef OFFHEAP + @Unretained + protected void setValueField(@Unretained Object v) { +#else + protected void setValueField(Object v) { +#endif + OffHeapRegionEntryHelper.setValue(this, v); + } + @Override +#ifdef OFFHEAP + @Retained +#endif + public Object _getValueRetain(RegionEntryContext context, boolean decompress) { + return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context); + } + + @Override + public long getAddress() { + return ohAddrUpdater.get(this); + } + + @Override + public boolean setAddress(long expectedAddr, long newAddr) { + return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr); + } + + @Override +#ifdef OFFHEAP + @Released +#endif + public void release() { + OffHeapRegionEntryHelper.releaseEntry(this); + } + + @Override + public void returnToPool() { + // Deadcoded for now; never was working +// if (this instanceof VMThinRegionEntryLongKey) { +// factory.returnToPool((VMThinRegionEntryLongKey)this); +// } + } +#else + private volatile Object value; + @Override + protected final Object getValueField() { + return this.value; + } + @Override + protected void setValueField(Object v) { + this.value = v; + } +#endif + 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() { + return this.hash; + } + protected void setEntryHash(int v) { + this.hash = v; + } + /** + * @see HashEntry#getNextEntry() + */ + public final HashEntry<Object, Object> getNextEntry() { + return this.next; + } + /** + * @see HashEntry#setNextEntry + */ + public final void setNextEntry(final HashEntry<Object, Object> n) { + this.next = n; + } +#ifdef DISK + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + // disk code +#ifdef LRU + protected void initialize(RegionEntryContext drs, Object value) { + boolean isBackup; + if (drs instanceof LocalRegion) { + isBackup = ((LocalRegion)drs).getDiskRegion().isBackup(); + } else if (drs instanceof PlaceHolderDiskRegion) { + isBackup = true; + } else { + throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion"); + } + // Delay the initialization of DiskID if overflow only + if (isBackup) { + diskInitialize(drs, value); + } + } + @Override + public final synchronized int updateAsyncEntrySize(EnableLRU capacityController) { + int oldSize = getEntrySize(); + int newSize = capacityController.entrySize( getKeyForSizing(), null); + setEntrySize(newSize); + int delta = newSize - oldSize; + return delta; + } +#else + protected void initialize(RegionEntryContext context, Object value) { + diskInitialize(context, value); + } + @Override + public int updateAsyncEntrySize(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(); + 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; +#endif + +#ifdef LRU + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + // lru code + @Override + public void setDelayedDiskId(LocalRegion r) { +#ifdef DISK + DiskStoreImpl ds = r.getDiskStore(); + long maxOplogSize = ds.getMaxOplogSize(); + this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList()); +#else + // nothing needed for LRUs with no disk +#endif + } + 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 + } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + public final 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() { + return areAnyBitsSet(RECENTLY_USED); + } + @Override + public final void setRecentlyUsed() { + setBits(RECENTLY_USED); + } + public final void unsetRecentlyUsed() { + clearBits(~RECENTLY_USED); + } + public final boolean testEvicted() { + return areAnyBitsSet(EVICTED); + } + public final void setEvicted() { + setBits(EVICTED); + } + public final 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 ) { + this.nextLRU = next; + } + public final LRUClockNode nextLRUNode() { + return this.nextLRU; + } + public final void setPrevLRUNode( LRUClockNode prev ) { + this.prevLRU = prev; + } + public final LRUClockNode prevLRUNode() { + return this.prevLRU; + } + public final int getEntrySize() { + return this.size; + } + protected final 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 + // default implementation. + return getKey(); +#else + // inline keys always report null for sizing since the size comes from the entry size + return null; +#endif + } +#endif + +#ifdef STATS + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + // stats code + @Override + public final void updateStatsForGet(boolean hit, long time) + { + setLastAccessed(time); + if (hit) { + incrementHitCount(); + } else { + incrementMissCount(); + } + } + @Override + protected final void setLastModified(long lastModified) { + _setLastModified(lastModified); + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + setLastAccessed(lastModified); + } + } + 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 final long getLastAccessed() throws InternalStatisticsDisabledException { + return this.lastAccessed; + } + private void setLastAccessed(long lastAccessed) { + this.lastAccessed = lastAccessed; + } + @Override + public final long getHitCount() throws InternalStatisticsDisabledException { + return this.hitCount & 0xFFFFFFFFL; + } + @Override + public final 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); + } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + @Override + public final void txDidDestroy(long currTime) { + setLastModified(currTime); + setLastAccessed(currTime); + this.hitCount = 0; + this.missCount = 0; + } + @Override + public boolean hasStats() { + return true; + } +#endif + +#ifdef VERSIONED + // 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; + + public int getEntryVersion() { + return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF); + } + + public long getRegionVersion() { + return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); + } + + + public long getVersionTimeStamp() { + return getLastModified(); + } + + public void setVersionTimeStamp(long time) { + setLastModified(time); + } + + public VersionSource getMemberID() { + return this.memberID; + } + 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()); + } else { + tag.setVersionTimeStamp(getVersionTimeStamp()); + } + } else { + setVersionTimeStamp(tag.getVersionTimeStamp()); + } + this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff); + } + + public void setMemberID(VersionSource memberID) { + this.memberID = memberID; + } + + @Override + public VersionStamp getVersionStamp() { + return this; + } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + public VersionTag asVersionTag() { + VersionTag tag = VersionTag.create(memberID); + tag.setEntryVersion(getEntryVersion()); + tag.setRegionVersion(this.regionVersionHighBytes, this.regionVersionLowBytes); + tag.setVersionTimeStamp(getVersionTimeStamp()); + tag.setDistributedSystemId(this.distributedSystemId); + 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(EntryEvent cacheEvent) { + // this keeps Eclipse 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 */ + public short getRegionVersionHighBytes() { + return this.regionVersionHighBytes; + } + + /** get rvv internal low bytes. Used by region entries for transferring to storage */ + public int getRegionVersionLowBytes() { + return this.regionVersionLowBytes; + } +#endif + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + // key code +#ifdef KEY_OBJECT + private final Object key; + @Override + public final Object getKey() { + return this.key; + } + +#elif defined(KEY_INT) + private final int key; + @Override + public final Object getKey() { + return this.key; + } + @Override + public boolean isKeyEqual(Object k) { + if (k instanceof Integer) { + return ((Integer) k).intValue() == this.key; + } + return false; + } + +#elif defined(KEY_LONG) + private final long key; + @Override + public final Object getKey() { + return this.key; + } + @Override + public boolean isKeyEqual(Object k) { + if (k instanceof Long) { + return ((Long) k).longValue() == this.key; + } + return false; + } + +#elif defined(KEY_UUID) + private final long keyMostSigBits; + private final long keyLeastSigBits; + @Override + public final Object getKey() { + return new UUID(this.keyMostSigBits, this.keyLeastSigBits); + } + @Override + public boolean isKeyEqual(Object k) { + if (k instanceof UUID) { + UUID uuid = (UUID) k; + return uuid.getLeastSignificantBits() == this.keyLeastSigBits + && uuid.getMostSignificantBits() == this.keyMostSigBits; + } + return false; + } + +#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 final Object getKey() { + int keylen = getKeyLength(); + char[] chars = new char[keylen]; + long tmpBits1 = this.bits1; + if (getEncoding() == 1) { + for (int i=0; i < keylen; i++) { + tmpBits1 >>= 8; + chars[i] = (char) (tmpBits1 & 0x00ff); + } + } else { + for (int i=0; i < keylen; i++) { + tmpBits1 >>= 16; + chars[i] = (char) (tmpBits1 & 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; + if (getEncoding() == 1) { + for (int i=0; i < keylen; i++) { + tmpBits1 >>= 8; + char c = (char) (tmpBits1 & 0x00ff); + if (str.charAt(i) != c) { + return false; + } + } + } else { + for (int i=0; i < keylen; i++) { + tmpBits1 >>= 16; + char c = (char) (tmpBits1 & 0x00FFff); + if (str.charAt(i) != c) { + return false; + } + } + } + return true; + } + } + return false; + } + +#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 final Object getKey() { + int keylen = getKeyLength(); + char[] chars = new char[keylen]; + long tmpBits1 = this.bits1; + long tmpBits2 = this.bits2; + if (getEncoding() == 1) { + for (int i=0; i < keylen; i++) { + if (i < 7) { + tmpBits1 >>= 8; + chars[i] = (char) (tmpBits1 & 0x00ff); + } else { + chars[i] = (char) (tmpBits2 & 0x00ff); + tmpBits2 >>= 8; + } + } + } else { + for (int i=0; i < keylen; i++) { + if (i < 3) { + tmpBits1 >>= 16; + chars[i] = (char) (tmpBits1 & 0x00FFff); + } else { + chars[i] = (char) (tmpBits2 & 0x00FFff); + tmpBits2 >>= 16; + } + } + } + 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; + long tmpBits2 = this.bits2; + if (getEncoding() == 1) { + for (int i=0; i < keylen; i++) { + char c; + if (i < 7) { + tmpBits1 >>= 8; + c = (char) (tmpBits1 & 0x00ff); + } else { + c = (char) (tmpBits2 & 0x00ff); + tmpBits2 >>= 8; + } + if (str.charAt(i) != c) { + return false; + } + } + } else { + for (int i=0; i < keylen; i++) { + char c; + if (i < 3) { + tmpBits1 >>= 16; + c = (char) (tmpBits1 & 0x00FFff); + } else { + c = (char) (tmpBits2 & 0x00FFff); + tmpBits2 >>= 16; + } + if (str.charAt(i) != c) { + return false; + } + } + } + return true; + } + } + return false; + } +#endif + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/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 41bd334..aa1b513 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 @@ -39,7 +39,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/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 1ae6628..ce659c0 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 @@ -39,7 +39,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/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 e046d65..5ea08a9 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 @@ -39,7 +39,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskLRURegionEntryHeapObjectKey extends VMStatsDiskLRURegionEntryHeap { public VMStatsDiskLRURegionEntryHeapObjectKey(RegionEntryContext context, Object key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey1.java index 57cab2d..0f92cb8 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey1.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey1.java @@ -39,7 +39,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskLRURegionEntryHeapStringKey1 extends VMStatsDiskLRURegionEntryHeap { public VMStatsDiskLRURegionEntryHeapStringKey1(RegionEntryContext context, String key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey2.java index 6f06653..b601648 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey2.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapStringKey2.java @@ -39,7 +39,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskLRURegionEntryHeapStringKey2 extends VMStatsDiskLRURegionEntryHeap { public VMStatsDiskLRURegionEntryHeapStringKey2(RegionEntryContext context, String key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapUUIDKey.java index 1dd4428..92ad469 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapUUIDKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryHeapUUIDKey.java @@ -40,7 +40,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapIntKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapIntKey.java index 421477d..abba32a 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapIntKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapIntKey.java @@ -43,7 +43,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskLRURegionEntryOffHeapIntKey extends VMStatsDiskLRURegionEntryOffHeap { public VMStatsDiskLRURegionEntryOffHeapIntKey(RegionEntryContext context, int key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapLongKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapLongKey.java index 76bf1e2..a721a52 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapLongKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapLongKey.java @@ -43,7 +43,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskLRURegionEntryOffHeapLongKey extends VMStatsDiskLRURegionEntryOffHeap { public VMStatsDiskLRURegionEntryOffHeapLongKey(RegionEntryContext context, long key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapObjectKey.java index a6186a5..4d6bfa7 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapObjectKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapObjectKey.java @@ -43,7 +43,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskLRURegionEntryOffHeapObjectKey extends VMStatsDiskLRURegionEntryOffHeap { public VMStatsDiskLRURegionEntryOffHeapObjectKey(RegionEntryContext context, Object key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey1.java index eac0af5..0fbd39c 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey1.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey1.java @@ -43,7 +43,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskLRURegionEntryOffHeapStringKey1 extends VMStatsDiskLRURegionEntryOffHeap { public VMStatsDiskLRURegionEntryOffHeapStringKey1(RegionEntryContext context, String key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey2.java index bba9ef3..eccc55c 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey2.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapStringKey2.java @@ -43,7 +43,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskLRURegionEntryOffHeapStringKey2 extends VMStatsDiskLRURegionEntryOffHeap { public VMStatsDiskLRURegionEntryOffHeapStringKey2(RegionEntryContext context, String key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapUUIDKey.java index 5ab2d0b..0593dc7 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapUUIDKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskLRURegionEntryOffHeapUUIDKey.java @@ -44,7 +44,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskLRURegionEntryOffHeapUUIDKey extends VMStatsDiskLRURegionEntryOffHeap { public VMStatsDiskLRURegionEntryOffHeapUUIDKey(RegionEntryContext context, UUID key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapIntKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapIntKey.java index d50319a..b09136a 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapIntKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapIntKey.java @@ -37,7 +37,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapLongKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapLongKey.java index de829cb..0c8fe86 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapLongKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapLongKey.java @@ -37,7 +37,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapObjectKey.java index b73bb52..b004295 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapObjectKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapObjectKey.java @@ -37,7 +37,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey1.java index 33ece05..d12f2d5 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey1.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey1.java @@ -37,7 +37,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey2.java index 894ac55..189d41d 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey2.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapStringKey2.java @@ -37,7 +37,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapUUIDKey.java index a283733..7646f45 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapUUIDKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryHeapUUIDKey.java @@ -38,7 +38,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapIntKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapIntKey.java index f45f772..71c67fb 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapIntKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapIntKey.java @@ -41,7 +41,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskRegionEntryOffHeapIntKey extends VMStatsDiskRegionEntryOffHeap { public VMStatsDiskRegionEntryOffHeapIntKey(RegionEntryContext context, int key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapLongKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapLongKey.java index c588595..41bb469 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapLongKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapLongKey.java @@ -41,7 +41,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskRegionEntryOffHeapLongKey extends VMStatsDiskRegionEntryOffHeap { public VMStatsDiskRegionEntryOffHeapLongKey(RegionEntryContext context, long key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapObjectKey.java index b66d160..85f0e13 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapObjectKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapObjectKey.java @@ -41,7 +41,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskRegionEntryOffHeapObjectKey extends VMStatsDiskRegionEntryOffHeap { public VMStatsDiskRegionEntryOffHeapObjectKey(RegionEntryContext context, Object key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey1.java index 92cef48..824aabb 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey1.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey1.java @@ -41,7 +41,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskRegionEntryOffHeapStringKey1 extends VMStatsDiskRegionEntryOffHeap { public VMStatsDiskRegionEntryOffHeapStringKey1(RegionEntryContext context, String key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey2.java index c9a9904..10c31ca 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey2.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey2.java @@ -41,7 +41,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEntryOffHeap { public VMStatsDiskRegionEntryOffHeapStringKey2(RegionEntryContext context, String key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapUUIDKey.java index 2e8f033..0e899fc 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapUUIDKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsDiskRegionEntryOffHeapUUIDKey.java @@ -42,7 +42,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsDiskRegionEntryOffHeapUUIDKey extends VMStatsDiskRegionEntryOffHeap { public VMStatsDiskRegionEntryOffHeapUUIDKey(RegionEntryContext context, UUID key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapIntKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapIntKey.java index 66b34d6..707adb9 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapIntKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapIntKey.java @@ -38,7 +38,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapLongKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapLongKey.java index 442736e..3524bbe 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapLongKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapLongKey.java @@ -38,7 +38,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java index d12066a..a5a0dc0 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java @@ -38,7 +38,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java index 1de7a21..04ea3d7 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java @@ -38,7 +38,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java index e1b58eb..2ca6440 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java @@ -38,7 +38,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java index a5c327b..d1d539e 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java @@ -39,7 +39,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./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) { http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapIntKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapIntKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapIntKey.java index 2d39ac5..dbb6e7b 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapIntKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapIntKey.java @@ -42,7 +42,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOffHeap { public VMStatsLRURegionEntryOffHeapIntKey(RegionEntryContext context, int key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapLongKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapLongKey.java index 0ffaddf..9bf356c 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapLongKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapLongKey.java @@ -42,7 +42,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOffHeap { public VMStatsLRURegionEntryOffHeapLongKey(RegionEntryContext context, long key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapObjectKey.java index f990481..486cbca 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapObjectKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapObjectKey.java @@ -42,7 +42,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntryOffHeap { public VMStatsLRURegionEntryOffHeapObjectKey(RegionEntryContext context, Object key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey1.java index 2e55620..b4ab253 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey1.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey1.java @@ -42,7 +42,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsLRURegionEntryOffHeapStringKey1 extends VMStatsLRURegionEntryOffHeap { public VMStatsLRURegionEntryOffHeapStringKey1(RegionEntryContext context, String key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey2.java index 6a7c0ae..fc72ec8 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey2.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapStringKey2.java @@ -42,7 +42,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsLRURegionEntryOffHeapStringKey2 extends VMStatsLRURegionEntryOffHeap { public VMStatsLRURegionEntryOffHeapStringKey2(RegionEntryContext context, String key, http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/df2f0c96/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapUUIDKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapUUIDKey.java index 7d1c8c7..8a4f04b 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapUUIDKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VMStatsLRURegionEntryOffHeapUUIDKey.java @@ -43,7 +43,7 @@ import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.Ha // key string2: KEY_STRING2 /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run - * bin/generateRegionEntryClasses.sh from the directory that contains your build.xml. + * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ public class VMStatsLRURegionEntryOffHeapUUIDKey extends VMStatsLRURegionEntryOffHeap { public VMStatsLRURegionEntryOffHeapUUIDKey(RegionEntryContext context, UUID key,
