Public

buildBackupClone

INTERNAL: CalculateChanges creates a change set for an existing object.

calculateChanges

calculateChangesForExistingObject

INTERNAL: CalculateChanges creates a change set for a new object.

calculateChangesForNewObject

INTERNAL: This is a place holder for reseting the listener on one of the
subclasses

clearChanges

INTERNAL: Create ObjectChangeSet through comparison. Used in cases where we need
to force change cal

createObjectChangeSetThroughComparison

INTERNAL: This method is used to disable changetracking temporarily

dissableEventProcessing

INTERNAL: This method is used to enable changetracking temporarily

enableEventProcessing

initialize

Used to track instances of the change policies without doing an instance of
check

isAttributeChangeTrackingPolicy

isObjectChangeTrackingPolicy

INTERNAL: This may cause a property change event to be raised to a listener in
the case that a liste

raiseInternalPropertyChangeEvent

INTERNAL: This method is used to revert an object within the unit of work

revertChanges

INTERNAL: Assign Changelistener to an aggregate object

setAggregateChangeListener

INTERNAL: Assign appropriate ChangeListener to PropertyChangeListener based on
the policy.

setChangeListener

INTERNAL: Set the ObjectChangeSet on the Listener, initially used for aggregate
support

setChangeSetOnListener

INTERNAL: Return true if the Object should be compared, false otherwise. This
method is implemented 

shouldCompareExistingObjectForChange

INTERNAL: This method is used internally to rest the policies back to original
state This is used wh

updateWithChanges

INTERNAL: In cases where a relationship with detached or new entities is merged
into itself previous

updateListenerForSelfMerge

isDeferredChangeDetectionPolicy

ObjectChangePolicy

Reading from database using SQL prepared statement

 A Java virtual machine.

 A VirtualMachine represents a Java virtual machine to which this Java vir

com.sun.tools.attach.VirtualMachine

A linear collection that supports element insertion and removal at both ends.
The name deque is shor

java.util.Deque

A Properties object is a Hashtable where the keys and values must be Strings.
Each property can have

java.util.Properties

TreeSet is an implementation of SortedSet. All optional operations (adding and
removing) are support

java.util.TreeSet

Main entry-point into the library.

Options represents a collection of Option objects, which describ

org.apache.commons.cli.Options

org.hamcrest.core.IsNull

findViewById

setContentView

requestLocationUpdates

/**
     * INTERNAL:
     * Builds a working copy clone directly from the database row.
     * This is the key method that allows us to execute queries against a
     * UnitOfWork while in transaction and not cache the results in the shared
     * cache.  This is because we might violate transaction isolation by
     * putting uncommitted versions of objects in the shared cache.
     */

// If the clone already exists then it may only need to be refreshed or returned.

// We call directly on the identity map to avoid going to the parent,

// registering if found, and wrapping the result.

// Acquire or create the cache key as is need once the object is build anyway.

// If there is a clone, and it is not a refresh then just return it.

// Also need to refresh if the clone is a partial object and query requires more than its fetch group.

// If not refreshing can get the object from the cache.

// PERF: Read-lock is not required on object as unit of work will acquire this on clone and object cannot gc and object identity is maintained.

// If the original is invalid or always refresh then need to refresh.

// Otherwise can just register the cached original object and return it.

// This code is copied from UnitOfWork.cloneAndRegisterObject.  Unlike

// that method we don't need to lock the shared cache, because

// are not building off of an original in the shared cache.

// The copy policy is easier to invoke if we have an original.

// intentionally put nothing in clones to originals, unless really was one.

// What happens if a copy policy is defined is not pleasant.

// This must be registered before it is built to avoid cycles.

// The version and read is set below in copyQueryInfoToCacheKey.

// Must avoid infinite loops while refreshing.

// If it was a clone the change listener must be cleared after.

// The change listener must be set before building the clone as aggregate/collections need the listener.

// Turn it 'off' to prevent unwanted events.

// Set fetch group before building object if a refresh to avoid fetching during building.

// Set fetch group after building object if not a refresh to avoid checking fetch during building.           

// If it was a clone the change listener must be cleared.

// PERF: Cache the primary key if implements PersistenceEntity.

/**
     * INTERNAL:
     * Builds a working copy clone directly from the database row.
     * This is the key method that allows us to execute queries against a
     * UnitOfWork while in transaction and not cache the results in the shared
     * cache.  This is because we might violate transaction isolation by
     * putting uncommitted versions of objects in the shared cache.
     */

// using shared isolation and the original is from the shared cache

// or using protected isolation and isolated client sessions

// serialized sopObject is a value corresponding to sopField in the row, row.sopObject==null;

// the following line sets deserialized sopObject into row.sopObject variable and sets sopField's value to null;

//workingClone = instantiateWorkingCopyCloneFromRow(databaseRow, query, primaryKey, unitOfWork);

// Create a new instance instead. The object is populated later by buildAttributesIntoWorkingCopyClone method.

// we are at this point because we have isolated protected entities to the UnitOfWork

// we should ensure that we populate the cache as well.

//If we are unable to access the shared cache because of any of the above settings at this point

// the cachekey will be null so the attribute building will not be able to access the shared cache.

//if we need to refresh the UOW then remove the cache key and the clone will be rebuilt not using any of the

//cache.  This should be updated to force the buildAttributesIntoWorkingCopyClone to refresh the objects

// Set fetch group after building object if not a refresh to avoid checking fetch during building.

//485984: Save the FetchGroup from the original

//if we need to refresh the UOW then remove the cache key and the clone will be rebuilt not using any of the 

//cache.  This should be updated to force the buildAttributesIntoWorkingCopyClone to refresh the objects 

How to use clearChangesmethodin org.eclipse.persistence.descriptors.changetracking.ObjectChangePolicy

Best Java code snippets using org.eclipse.persistence.descriptors.changetracking.ObjectChangePolicy.clearChanges (Showing top 3 results out of 315)

How to use
clearChanges
method
in
org.eclipse.persistence.descriptors.changetracking.ObjectChangePolicy