/**
* Convenience method to load fields from the datastore. Note that if the fieldNumbers is
* null/empty we still should call the persistence handler since it may mean that the version
* field needs loading.
*
* @param fieldNumbers The field numbers.
*/
protected void loadFieldsFromDatastore(int[] fieldNumbers) {
if (myLC.isNew() && myLC.isPersistent() && !isFlushedNew()) {
// Not yet flushed new persistent object to datastore so no point in "loading"
return;
}
if ((flags & FLAG_NEED_INHERITANCE_VALIDATION)
!= 0) // TODO Merge this into fetch object handler
{
String className =
getStoreManager().getClassNameForObjectID(myID, myEC.getClassLoaderResolver(), myEC);
if (!getObject().getClass().getName().equals(className)) {
myEC.removeObjectFromLevel1Cache(myID);
myEC.removeObjectFromLevel2Cache(myID);
throw new NucleusObjectNotFoundException(
"Object with id "
+ myID
+ " was created without validating of type "
+ getObject().getClass().getName()
+ " but is actually of type "
+ className);
}
flags &= ~FLAG_NEED_INHERITANCE_VALIDATION;
}
// TODO If the field has "loadFetchGroup" defined, then add it to the fetch plan etc
getStoreManager().getPersistenceHandler().fetchObject(this, fieldNumbers);
}
/**
* Use this in place of valueOf.
*
* @param value real value
* @return LifeCycleState corresponding to the value
*/
public static LifeCycleState fromValue(String value) {
if (value == null || "".equals(value)) {
throw new IllegalArgumentException("Value cannot be null or empty!");
}
for (LifeCycleState enumEntry : LifeCycleState.values()) {
if (enumEntry.toString().equals(value)) {
return enumEntry;
}
}
throw new IllegalArgumentException("Cannot create enum from " + value + " value!");
}
/**
* Method invoked just before a transaction starts for the ExecutionContext managing us.
*
* @param tx The transaction
*/
public void preBegin(org.datanucleus.Transaction tx) {
preStateChange();
try {
myLC = myLC.transitionBegin(this, tx);
} finally {
postStateChange();
}
}
/** Method to change the object state to nontransactional. */
public void makeNontransactional() {
preStateChange();
try {
myLC = myLC.transitionMakeNontransactional(this);
} finally {
postStateChange();
}
}
/**
* Method to retrieve the object.
*
* @param fgOnly Only load the current fetch group fields
*/
public void retrieve(boolean fgOnly) {
preStateChange();
try {
myLC = myLC.transitionRetrieve(this, fgOnly);
} finally {
postStateChange();
}
}
/** Method to refresh the object. */
public void refresh() {
preStateChange();
try {
myLC = myLC.transitionRefresh(this);
} finally {
postStateChange();
}
}
public static PlanStatus fromJsonObject(PlanResultKey planResultKey, JSONObject jsonObject)
throws JSONException {
final String state = jsonObject.getString("state");
final String lifecycle = jsonObject.getString("lifeCycleState");
final BuildState buildState = BuildState.getInstance(state);
final LifeCycleState lifeCycleState = LifeCycleState.getInstance(lifecycle);
return new PlanStatus(planResultKey, buildState, lifeCycleState, true);
}
/**
* This method is invoked just after a commit is performed in a Transaction involving the
* persistable object managed by this StateManager
*
* @param tx The transaction
*/
public void postCommit(org.datanucleus.Transaction tx) {
preStateChange();
try {
myLC = myLC.transitionCommit(this, tx);
if (transactionalVersion != myVersion) {
myVersion = transactionalVersion;
}
this.lockMode = LockManager.LOCK_MODE_NONE;
} finally {
postStateChange();
}
}
/**
* This method is invoked just before a rollback is performed in a Transaction involving the
* persistable object managed by this StateManager.
*
* @param tx The transaction
*/
public void preRollback(org.datanucleus.Transaction tx) {
preStateChange();
try {
myEC.clearDirty(this);
myLC = myLC.transitionRollback(this, tx);
if (transactionalVersion != myVersion) {
transactionalVersion = myVersion;
}
this.lockMode = LockManager.LOCK_MODE_NONE;
} finally {
postStateChange();
}
}
/** Makes Transactional Transient instances persistent. */
public void makePersistentTransactionalTransient() {
preStateChange();
try {
if (myLC.isTransactional && !myLC.isPersistent) {
// make the transient instance persistent in the datastore, if is transactional and
// !persistent
makePersistent();
myLC = myLC.transitionMakePersistent(this);
}
} finally {
postStateChange();
}
}
/**
* Convenience method to retrieve field values from an L2 cached object if they are loaded in that
* object. If the object is not in the L2 cache then just returns, and similarly if the required
* fields aren't available.
*
* @param fieldNumbers Numbers of fields to load from the L2 cache
* @return The fields that couldn't be loaded
*/
protected int[] loadFieldsFromLevel2Cache(int[] fieldNumbers) {
// Only continue if there are fields, and not being deleted/flushed etc
if (fieldNumbers == null
|| fieldNumbers.length == 0
|| myEC.isFlushing()
|| myLC.isDeleted()
|| isDeleting()
|| getExecutionContext().getTransaction().isCommitting()) {
return fieldNumbers;
}
// TODO Drop this check when we're confident that this doesn't affect some use-cases
if (!myEC.getNucleusContext()
.getConfiguration()
.getBooleanProperty(PropertyNames.PROPERTY_CACHE_L2_LOADFIELDS, true)) {
return fieldNumbers;
}
Level2Cache l2cache = myEC.getNucleusContext().getLevel2Cache();
if (l2cache != null && myEC.getNucleusContext().isClassCacheable(cmd)) {
CachedPC<T> cachedPC = l2cache.get(myID);
if (cachedPC != null) {
int[] cacheFieldsToLoad =
ClassUtils.getFlagsSetTo(cachedPC.getLoadedFields(), fieldNumbers, true);
if (cacheFieldsToLoad != null && cacheFieldsToLoad.length > 0) {
if (NucleusLogger.CACHE.isDebugEnabled()) {
NucleusLogger.CACHE.debug(
Localiser.msg(
"026034",
StringUtils.toJVMIDString(getObject()),
myID,
StringUtils.intArrayToString(cacheFieldsToLoad)));
}
L2CacheRetrieveFieldManager l2RetFM = new L2CacheRetrieveFieldManager(this, cachedPC);
this.replaceFields(cacheFieldsToLoad, l2RetFM);
int[] fieldsNotLoaded = l2RetFM.getFieldsNotLoaded();
if (fieldsNotLoaded != null) {
for (int i = 0; i < fieldsNotLoaded.length; i++) {
loadedFields[fieldsNotLoaded[i]] = false;
}
}
}
}
}
return ClassUtils.getFlagsSetTo(loadedFields, fieldNumbers, false);
}
/** Method to change the object state to write-field. */
protected void transitionWriteField() {
try {
if (myEC.getMultithreaded()) {
myEC.getLock().lock();
lock.lock();
}
preStateChange();
try {
myLC = myLC.transitionWriteField(this);
} finally {
postStateChange();
}
} finally {
if (myEC.getMultithreaded()) {
lock.unlock();
myEC.getLock().unlock();
}
}
}
/** Method to change the object state to evicted. */
public void evict() {
if (myLC != myEC.getNucleusContext().getApiAdapter().getLifeCycleState(LifeCycleState.P_CLEAN)
&& myLC
!= myEC.getNucleusContext()
.getApiAdapter()
.getLifeCycleState(LifeCycleState.P_NONTRANS)) {
return;
}
preStateChange();
try {
try {
getCallbackHandler().preClear(getObject());
getCallbackHandler().postClear(getObject());
} finally {
myLC = myLC.transitionEvict(this);
}
} finally {
postStateChange();
}
}
/**
* Method to change the object state to read-field.
*
* @param isLoaded if the field was previously loaded
*/
protected void transitionReadField(boolean isLoaded) {
try {
if (myEC.getMultithreaded()) {
myEC.getLock().lock();
lock.lock();
}
if (myLC == null) {
return;
}
preStateChange();
try {
myLC = myLC.transitionReadField(this, isLoaded);
} finally {
postStateChange();
}
} finally {
if (myEC.getMultithreaded()) {
lock.unlock();
myEC.getLock().unlock();
}
}
}
/**
* Accessor for whether the instance is newly persistent yet hasnt yet been flushed to the
* datastore.
*
* @return Whether not yet flushed to the datastore
*/
public boolean isWaitingToBeFlushedToDatastore() {
// Return true if object is new and not yet flushed to datastore
return myLC.stateType() == LifeCycleState.P_NEW && !isFlushedNew();
}
