@Override public RegionEntry getRegionEntry(Object key) { return this.entries.getEntry(key); }
/** return null if not found */ @Override public RegionEntry basicGetEntry(Object key) { // ok to ignore tx state; all callers are non-transactional RegionEntry regionEntry = this.entries.getEntry(key); if (regionEntry != null && regionEntry.isRemoved()) { regionEntry = null; } return regionEntry; }
/** Internal method for getting the underlying RegionEntry */ public RegionEntry getRegionEntry() { RegionEntry regionEntry = LocalRegion.this.getRegionMap().getEntry(this.key); if (regionEntry == null) { throw new EntryDestroyedException(this.key.toString()); } return regionEntry; }
/** * Gets the value from VM, if present, otherwise from disk without fault in. */ @Override public Object getValueInVMOrDiskWithoutFaultIn(Object key) throws EntryNotFoundException { RegionEntry re = this.entries.getEntry(key); if (re == null) { throw new EntryNotFoundException(key.toString()); } return re.getValueInVMOrDiskWithoutFaultIn(this); }
public static boolean checkForValidStateAfterRegisterInterest(LocalRegion region, Object key, Object serverValue) { int cacheEntryState = -1; RegionEntry re = region.entries.getEntry(key); if (re == null) { // nonexistent cacheEntryState = 0; } else { Token token = re.getValueAsToken(); if (token == Token.DESTROYED) { // destroyed cacheEntryState = 3; } else if (token == Token.INVALID) { // invalid cacheEntryState = 2; } else { // valid cacheEntryState = 1; } } // A matrix During register interest response processing // 4 nonexistent, valid , invalid,destroyed // 2 invalid, valid boolean matrix[][] = {{true, true}, {false, false}, {true, true}, {true, true}}; int registerInterstResState = 0; // invalid if (serverValue != null) { registerInterstResState = 1; // valid } return matrix[cacheEntryState][registerInterstResState]; }
@Override public DiskEntry getDiskEntry(Object key) { // should return tombstone as an valid entry RegionEntry regionEntry = this.entries.getEntry(key); if (regionEntry != null && regionEntry.isRemoved() && !regionEntry.isTombstone()) { regionEntry = null; } return (DiskEntry) regionEntry; }
RegionEntry re = region.entries.getEntry(key); if (re == null) {
/** * Returns the value of the entry with the given key as it is stored on disk. While the value may * be read from disk, it is <b>not</b> stored into the entry in the VM. This method is intended * for testing purposes only. * * @throws EntryNotFoundException No entry with {@code key} exists * @throws IllegalStateException If this region does not write to disk * * @see RegionEntry#getValueOnDisk * * @since GemFire 3.2 */ @Override public Object getValueOnDisk(Object key) throws EntryNotFoundException { // Ok for this to ignore tx state RegionEntry re = this.entries.getEntry(key); if (re == null) { throw new EntryNotFoundException(key.toString()); } return re.getValueOnDisk(this); }
/** * Returns the value of the entry with the given key as it is stored present in the buffer or * disk. While the value may be read from disk or buffer, it is <b>not</b> stored into the entry * in the VM. This is different from getValueonDisk in that it checks for a value both in asynch * buffers ( subject to asynch mode enabled) as well as Disk * * @throws EntryNotFoundException No entry with {@code key} exists * @throws IllegalStateException If this region does not write to disk * * @see RegionEntry#getValueOnDisk * * @since GemFire 5.1 */ @Override public Object getValueOnDiskOrBuffer(Object key) throws EntryNotFoundException { // Ok for this to ignore tx state RegionEntry re = this.entries.getEntry(key); if (re == null) { throw new EntryNotFoundException(key.toString()); } return re.getValueOnDiskOrBuffer(this); }
@Override public DiskEntry getDiskEntry(Object key) { RegionEntry re = getRecoveredEntryMap().getEntry(key); if (re != null && re.isRemoved() && !re.isTombstone()) { re = null; } return (DiskEntry) re; }
/** * Test Method: Fetch a value from the local cache * * @param key The kye * @return the value associated with that key * @see LocalRegion#get(Object, Object, boolean, EntryEventImpl) */ public Object localCacheGet(Object key) { RegionEntry re = getRegionMap().getEntry(key); if (re == null || re.isDestroyedOrRemoved()) { return null; } else { return re.getValue(this); // OFFHEAP: spin until we can copy into a heap cd? } }
protected boolean nonTXContainsKey(KeyInfo keyInfo) { boolean contains = getRegionMap().containsKey(keyInfo.getKey()); if (contains && this.imageState.isClient()) { // fix for bug #40871 - concurrent RI causes containsKey for destroyed entry // to return true RegionEntry regionEntry = this.entries.getEntry(keyInfo.getKey()); if (regionEntry == null || regionEntry.isDestroyedOrRemoved()) { contains = false; } } return contains; }
/** * @param access true if caller wants last accessed time updated * @param allowTombstones whether an entry with a TOMBSTONE value can be returned */ protected Region.Entry nonTXGetEntry(KeyInfo keyInfo, boolean access, boolean allowTombstones) { final Object key = keyInfo.getKey(); RegionEntry re = this.entries.getEntry(key); boolean miss = re == null || re.isDestroyedOrRemoved(); if (access) { updateStatsForGet(re, !miss); } if (re == null) { return null; } if (re.isTombstone()) { if (!allowTombstones) { return null; } // else return an entry (client GII / putAll results) } else if (miss) { return null; } return new NonTXEntry(re); }
/** * establish the old value in this event as the current cache value, whether in memory or on disk */ public void setOldValueForQueryProcessing() { RegionEntry reentry = getRegion().getRegionMap().getEntry(this.getKey()); if (reentry != null) { @Retained Object v = reentry.getValueOffHeapOrDiskWithoutFaultIn(getRegion()); if (!(v instanceof Token)) { // v has already been retained. basicSetOldValue(v); // this event now owns the retention of v. } } }
@Retained Object nonTXbasicGetValueInVM(KeyInfo keyInfo) { RegionEntry regionEntry = this.entries.getEntry(keyInfo.getKey()); if (regionEntry == null) { checkEntryNotFound(keyInfo.getKey()); } // OFFHEAP returned to callers Object value = regionEntry.getValueInVM(this); if (Token.isRemoved(value)) { checkEntryNotFound(keyInfo.getKey()); } if (value == Token.NOT_AVAILABLE) { return null; } return value; }
RegionEntry ent = null; try { ent = bucketRegion.entries.getEntry(key);
/** * Returns true if the cache already has this key as an invalid entry with a version >= the one in * the given event. This is used in cache-miss processing to avoid overwriting the entry when it * is not necessary, so that we avoid invoking cache listeners. * * @return whether the entry is already invalid */ private boolean alreadyInvalid(Object key, EntryEventImpl event) { @Unretained(ENTRY_EVENT_NEW_VALUE) Object newValue = event.getRawNewValue(); if (newValue == null || Token.isInvalid(newValue)) { RegionEntry entry = this.entries.getEntry(key); if (entry != null) { synchronized (entry) { if (entry.isInvalid()) { VersionStamp stamp = entry.getVersionStamp(); if (stamp == null || event.getVersionTag() == null) { return true; } if (stamp.getEntryVersion() >= event.getVersionTag().getEntryVersion()) { return true; } } } } } return false; }
throws EntryNotFoundException, IOException { RegionEntry re = null; re = this.entries.getEntry(key); if (re == null) { return NULLVALUE;
RegionEntry entry = this.entries.getEntry(keyInfo.getKey()); boolean result = entry != null; if (result) {
regionEntry = this.entries.getEntry(keyInfo.getKey());