com.gemstone.gemfire.internal.cache.TXEntry Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gemfire-core Show documentation
Show all versions of gemfire-core Show documentation
SnappyData store based off Pivotal GemFireXD
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* Licensed 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. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.internal.cache;
import com.gemstone.gemfire.cache.CacheStatistics;
import com.gemstone.gemfire.cache.EntryDestroyedException;
import com.gemstone.gemfire.cache.IllegalTransactionStateException;
import com.gemstone.gemfire.cache.Region;
import com.gemstone.gemfire.cache.StatisticsDisabledException;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.internal.offheap.annotations.Unretained;
/** ******************* Class Entry ***************************************** */
/**
* Note: if changing to non-final, then change the getClass() comparison in
* GemFireContainer.PREntriesFullIterator.extractRowLocationFromEntry
*/
public final class TXEntry implements Region.Entry, TXEntryId {
private final LocalRegion localRegion;
private final LocalRegion dataRegion;
private final Object key;
private final TXEntryState txes;
private final TXState myTX;
/**
* Create an Entry given a key. The returned Entry may or may not be
* destroyed.
*/
TXEntry(final LocalRegion localRegion, final LocalRegion dataRegion,
final Object key, final TXEntryState tx, final TXState txState) {
this.localRegion = localRegion;
this.dataRegion = dataRegion;
this.key = key;
this.txes = tx;
this.myTX = txState;
//Assert that these contructors are invoked only
// via factory path. I am not able to make them private
// because GemFireXDTxEntry needs extending TxEntry
/*LogWriter logger = localRegion.getCache().getLogger();
if(logger.fineEnabled()) {
StackTraceElement[] traces =Thread.currentThread().getStackTrace();
//The third element should be the factory one
StackTraceElement trace = traces[2];
Assert.assertTrue(TxEntryFactory.class.isAssignableFrom(trace.getClass()));
Assert.assertTrue(trace.getMethodName().equals("createEntry"));
}*/
}
public boolean isLocal() {
return true;
}
protected void checkTX() {
// Protect against the case where this instance was handed to a different
// thread w/ or w/o a transaction
// Protect against the case where the transaction associated with this entry
// is not in progress
// [sumedh] avoiding checking for LocalRegion's current TX since it involves
// an expensive ThreadLocal lookup and it is okay to live with switching to
// different thread as long as original transaction is alive
//if (!this.myTX.isInProgressAndSameAs(this.localRegion.getTXState())) {
if (!this.myTX.isInProgress()) {
throw new IllegalTransactionStateException(LocalizedStrings
.LocalRegion_REGIONENTRY_WAS_CREATED_WITH_TRANSACTION_THAT_IS_NO_LONGER_ACTIVE
.toLocalizedString(this.myTX.getTransactionId()));
}
}
public boolean isDestroyed() {
checkTX();
return !this.txes.existsLocally();
}
public Object getKey() {
checkEntryDestroyed();
return this.key;
}
@Unretained
public Object getValue() {
checkTX();
@Unretained final Object value = this.myTX.getTXValue(this.txes, this.localRegion,
this.dataRegion, false, false);
if (value == null) {
throw new EntryDestroyedException(this.key.toString());
}
else if (Token.isInvalid(value)) {
return null;
}
return value;
}
public LocalRegion getRegion() {
checkEntryDestroyed();
return this.localRegion;
}
public final TXEntryState getTXEntryState() {
return this.txes;
}
public CacheStatistics getStatistics() {
// prefer entry destroyed exception over statistics disabled exception
checkEntryDestroyed();
checkTX();
if (!this.localRegion.statisticsEnabled) {
throw new StatisticsDisabledException(
LocalizedStrings.LocalRegion_STATISTICS_DISABLED_FOR_REGION_0
.toLocalizedString(this.localRegion.getFullPath()));
}
// On a TXEntry stats are non-existent so return a dummy impl
return new CacheStatistics() {
public long getLastModifiedTime() {
return (getRegion() != null) ? ((LocalRegion) getRegion())
.cacheTimeMillis() : System.currentTimeMillis();
}
public long getLastAccessedTime() {
return (getRegion() != null) ? ((LocalRegion) getRegion())
.cacheTimeMillis() : System.currentTimeMillis();
}
public long getMissCount() {
return 0;
}
public long getHitCount() {
return 0;
}
public float getHitRatio() {
return 0;
}
public void resetCounts() {
}
};
}
public Object getUserAttribute() {
throw new UnsupportedOperationException(
LocalizedStrings.TXEntry_UA_NOT_SUPPORTED.toLocalizedString());
/*
checkTX();
throwIfUAOperationForPR();
TXEntryUserAttrState tx = txReadUA(this.keyInfo);
if (tx != null) {
return tx.getPendingValue();
}
else {
checkEntryDestroyed();
return this.localRegion.basicGetEntryUserAttribute(this.keyInfo.getKey());
}
*/
}
public Object setUserAttribute(Object value) {
throw new UnsupportedOperationException(
LocalizedStrings.TXEntry_UA_NOT_SUPPORTED.toLocalizedString());
/*
checkTX();
throwIfUAOperationForPR();
TXEntryUserAttrState tx = txWriteUA(this.keyInfo);
if (tx != null) {
return tx.setPendingValue(value);
}
else {
checkEntryDestroyed();
if (this.localRegion.entryUserAttributes == null) {
this.localRegion.entryUserAttributes = new Hashtable();
}
return this.localRegion.entryUserAttributes.put(keyInfo, value);
}
*/
}
/*
private void throwIfUAOperationForPR() {
if (this.localRegion instanceof PartitionedRegion) {
throw new UnsupportedOperationException(LocalizedStrings.
TXEntry_UA_NOT_SUPPORTED_FOR_PR.toLocalizedString());
}
}
*/
@Override
public boolean equals(Object obj) {
if (!(obj instanceof TXEntry)) {
return false;
}
final TXEntry txe = (TXEntry)obj;
return this.txes == txe.txes;
}
@Override
public int hashCode() {
return this.key.hashCode() ^ this.localRegion.hashCode();
}
@Override
public String toString() {
return "key=" + this.key + ";pendingValue=" + this.txes.getPendingValue();
}
////////////////// Private Methods
// /////////////////////////////////////////
/*
* throws CacheClosedException or EntryDestroyedException if this entry is
* destroyed.
*/
private void checkEntryDestroyed() {
if (isDestroyed()) {
throw new EntryDestroyedException(this.key.toString());
}
}
/*
private final TXEntryUserAttrState txReadUA(KeyInfo ki) {
TXRegionState txr = this.myTX.readRegion(this.localRegion);
if (txr != null) {
return txr.readEntryUserAttr(ki.getKey());
}
else {
return null;
}
}
protected final TXEntryUserAttrState txWriteUA(KeyInfo ki) {
final LocalRegion dataReg = this.localRegion.getDataRegionForWrite(ki);
final TXRegionState txr = this.myTX.writeRegion(dataReg);
if (txr != null) {
return txr.writeEntryUserAttr(ki.getKey(), this.localRegion);
}
else {
return null;
}
}
*/
/**
* @since 5.0
*/
public Object setValue(Object value) {
return this.localRegion.put(this.getKey(), value);
}
/**
* @see TXEntryId#getTXId()
*/
public TXId getTXId() {
return this.myTX.getTransactionId();
}
}