Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/sco/Vector.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/sco/Vector.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/sco/Vector.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/sco/Vector.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,737 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * sco.Vector.java + */ + +package org.apache.jdo.impl.sco; + +import java.util.Collection; +import java.util.Iterator; + +import javax.jdo.JDOFatalInternalException; +import javax.jdo.JDOUserException; + +import org.apache.jdo.sco.SCO; +import org.apache.jdo.sco.SCOCollection; +import org.apache.jdo.state.StateManagerInternal; +import org.apache.jdo.util.I18NHelper; + + +/** + * A mutable 2nd class object that represents Vector. + * @author Marina Vatkina + * @version 1.0.1 + * @see java.util.Vector + */ +public class Vector extends java.util.Vector + implements SCOCollection { + + private transient StateManagerInternal owner; + + private transient int fieldNumber = -1; + + private transient Class elementType; + + private transient boolean allowNulls; + + private transient java.util.Vector added = new java.util.Vector(); + + private transient java.util.Vector removed = new java.util.Vector(); + + /** + * I18N message handler + */ + private final static I18NHelper msg = I18NHelper.getInstance( + "org.apache.jdo.impl.sco.Bundle"); // NOI18N + + private final static String _Vector = "Vector"; // NOI18N + + /** + * Constructs an empty vector so that its internal data array + * has size <tt>10</tt> and its standard capacity increment is + * zero. + * @param elementType the element types allowed + * @param allowNulls true if nulls are allowed + */ + public Vector(Class elementType, boolean allowNulls) { + super(); + this.elementType = elementType; + this.allowNulls = allowNulls; + } + + /** + * Constructs an empty vector with the specified initial capacity and + * with its capacity increment equal to zero. + * + * @param elementType the element types allowed + * @param allowNulls true if nulls are allowed + * @param initialCapacity the initial capacity of the vector. + * @exception IllegalArgumentException if the specified initial capacity + * is negative + */ + public Vector(Class elementType, boolean allowNulls, int initialCapacity) { + super(initialCapacity); + this.elementType = elementType; + this.allowNulls = allowNulls; + } + + /** ------------------Public Methods----------------*/ + + /** + * Sets the component at the specified <code>index</code> of this + * vector to be the specified object. The previous component at that + * position is discarded.<p> + * + * @param obj what the component is to be set to. + * @param index the specified index. + * @exception ArrayIndexOutOfBoundsException if the index was invalid. + * @see java.util.Vector + */ + public synchronized void setElementAt(Object obj, int index) { + SCOHelper.debug(_Vector, "setElementAt"); // NOI18N + + if (obj == null) { + SCOHelper.assertNullsAllowed(obj, allowNulls); + // It is actualy remove + this.removeElementAt(index); + } + + SCOHelper.assertElementType(obj, elementType); + // Mark the field as dirty + this.makeDirty(); + + Object o = super.elementAt(index); + super.setElementAt(obj, index); + + if (added.remove(o) == false) { + removed.add(o); + } + if (removed.remove(obj) == false) { + added.add(obj); + } + // Apply updates + this.trackUpdates(true); + } + + /** + * Deletes the component at the specified index. + * + * @param index the index of the object to remove. + * @exception ArrayIndexOutOfBoundsException if the index was invalid. + * @see java.util.Vector + */ + public synchronized void removeElementAt(int index) { + SCOHelper.debug(_Vector, "removeElementAt"); // NOI18N + + // Mark the field as dirty + this.makeDirty(); + + Object obj = super.elementAt(index); + super.removeElementAt(index); + if (added.remove(obj) == false) + removed.add(obj); + + // Apply updates + this.trackUpdates(true); + + } + + /** + * Inserts the specified object as a component in this vector at the + * specified <code>index</code>. + * + * @param obj the component to insert. + * @param index where to insert the new component. + * @exception ArrayIndexOutOfBoundsException if the index was invalid. + * @see java.util.Vector + */ + public synchronized void insertElementAt(Object obj, int index) { + SCOHelper.debug(_Vector, "insertElementAt"); // NOI18N + + SCOHelper.assertNullsAllowed(obj, allowNulls); + SCOHelper.assertElementType(obj, elementType); + // Mark the field as dirty + this.makeDirty(); + + super.insertElementAt(obj, index); + if (removed.remove(obj) == false) { + added.add(obj); + } + + // Apply updates + this.trackUpdates(true); + } + + /** + * Adds the specified component to the end of this vector, + * increasing its size by one. + * + * @param obj the component to be added. + * @see java.util.Vector + */ + public synchronized void addElement(Object obj) { + SCOHelper.debug(_Vector, "addElement"); // NOI18N + + SCOHelper.assertNullsAllowed(obj, allowNulls); + SCOHelper.assertElementType(obj, elementType); + // Mark the field as dirty + this.makeDirty(); + + super.addElement(obj); + if (removed.remove(obj) == false) { + added.add(obj); + } + + // Apply updates + this.trackUpdates(true); + } + + /** + * Removes the first (lowest-indexed) occurrence of the argument + * from this vector. + * + * @param obj the component to be removed. + * @return <code>true</code> if the argument was a component of this + * vector; <code>false</code> otherwise. + * @see java.util.Vector + */ + public synchronized boolean removeElement(Object obj) { + SCOHelper.debug(_Vector, "removeElement"); // NOI18N + + // Because java.util.Vector.removeElement(Object) calls internally + // removeElementAt(int) which is not supported, we cannot rely on jdk. + // We need to process remove here. + + // Mark the field as dirty + this.makeDirty(); + + int i = super.indexOf(obj); + if (i > -1) { + super.removeElementAt(i); + + if (added.remove(obj) == false) { + removed.add(obj); + } + // Apply updates + this.trackUpdates(true); + return true; + } + return false; + + } + + /** + * Removes all components from this vector and sets its size to zero.<p> + * + * @see java.util.Vector + */ + public synchronized void removeAllElements() { + SCOHelper.debug(_Vector, "removeElements"); // NOI18N + + // Mark the field as dirty + this.makeDirty(); + + for (Iterator iter = super.iterator(); iter.hasNext();) { + Object o = iter.next(); + if (added.remove(o) == false) { + removed.add(o); + } + } + added.clear(); + + super.removeAllElements(); + + // Apply updates + this.trackUpdates(true); + } + + + + /** + * Replaces the element at the specified position in this Vector with the + * specified element. + * + * @param index index of element to replace. + * @param element element to be stored at the specified position. + * @return the element previously at the specified position. + * @exception ArrayIndexOutOfBoundsException index out of range + * (index < 0 || index >= size()). + * @exception IllegalArgumentException fromIndex > toIndex. + * @see java.util.Vector + */ + public synchronized Object set(int index, Object element) { + SCOHelper.debug(_Vector, "set"); // NOI18N + + if (element == null) { + SCOHelper.assertNullsAllowed(element, allowNulls); + // It is actualy remove + return this.remove(index); + } + + SCOHelper.assertElementType(element, elementType); + // Mark the field as dirty + this.makeDirty(); + + Object o = super.set(index, element); + if (added.remove(o) == false) { + removed.add(o); + } + if (removed.remove(element) == false) { + added.add(element); + } + + // Apply updates + this.trackUpdates(true); + + return o; + } + + + /** + * Appends the specified element to the end of this Vector. + * + * @param o element to be appended to this Vector. + * @return true (as per the general contract of Collection.add). + * @see java.util.Vector + */ + public synchronized boolean add(Object o) { + SCOHelper.debug(_Vector, "add"); // NOI18N + + SCOHelper.assertNullsAllowed(o, allowNulls); + SCOHelper.assertElementType(o, elementType); + // Mark the field as dirty + this.makeDirty(); + + if (removed.remove(o) == false) { + added.add(o); + } + + boolean modified = super.add(o); + + // Apply updates + this.trackUpdates(modified); + + return modified; + } + + /** + * Removes the first occurrence of the specified element in this Vector + * If the Vector does not contain the element, it is unchanged. + * + * @param o element to be removed from this Vector, if present. + * @return true if the Vector contained the specified element. + * @see java.util.Vector + */ + public boolean remove(Object o) { + SCOHelper.debug(_Vector, "remove"); // NOI18N + + return this.removeElement(o); + } + + /** + * Inserts the specified element at the specified position in this Vector. + * + * @param index index at which the specified element is to be inserted. + * @param element element to be inserted. + * @exception ArrayIndexOutOfBoundsException index is out of range + * (index < 0 || index > size()). + * @see java.util.Vector + */ + public void add(int index, Object element) { + SCOHelper.debug(_Vector, "add by index"); // NOI18N + + this.insertElementAt(element, index); + } + + /** + * Removes the element at the specified position in this Vector. + * shifts any subsequent elements to the left (subtracts one from their + * indices). Returns the element that was removed from the Vector. + * + * @param index the index of the element to removed. + * @exception ArrayIndexOutOfBoundsException index out of range (index + * < 0 || index >= size()). + * @see java.util.Vector + */ + public synchronized Object remove(int index) { + SCOHelper.debug(_Vector, "remove by index"); // NOI18N + + + // Mark the field as dirty + this.makeDirty(); + + Object obj = super.remove(index); + if (added.remove(obj) == false) { + removed.add(obj); + } + + // Apply updates + this.trackUpdates(true); + + return obj; + } + + /** + * Removes all of the elements from this Vector. The Vector will + * be empty after this call returns (unless it throws an exception). + * + * @see java.util.Vector + */ + public void clear() { + SCOHelper.debug(_Vector, "clear"); // NOI18N + + this.removeAllElements(); + } + + /** + * Appends all of the elements in the specified Collection to the end of + * this Vector, in the order that they are returned by the specified + * Collection's Iterator. + * + * @param c elements to be inserted into this Vector. + * @see java.util.Vector + */ + public synchronized boolean addAll(Collection c) { + SCOHelper.debug(_Vector, "addAll"); // NOI18N + + // iterate the collection and make a list of wrong elements. + Throwable[] err = new Throwable[c.size()]; + int l = 0; + + Iterator i = c.iterator(); + while (i.hasNext()) { + Object o = i.next(); + try { + SCOHelper.assertNullsAllowed(o, allowNulls); + SCOHelper.assertElementType(o, elementType); + } catch (Throwable e) { + err[l++] = e; + } + } + SCOHelper.validateResult(l, err); + + // Mark the field as dirty + this.makeDirty(); + + removed.removeAll(c); + added.addAll(c); + + boolean modified = super.addAll(c); + + // Apply updates + this.trackUpdates(modified); + + return modified; + } + + /** + * Removes from this Vector all of its elements that are contained in the + * specified Collection. + * + * @return true if this Vector changed as a result of the call. + * @see java.util.Vector + */ + public synchronized boolean removeAll(Collection c) { + SCOHelper.debug(_Vector, "removeAll"); // NOI18N + + boolean modified = false; + // Mark the field as dirty + this.makeDirty(); + + Iterator e = c.iterator(); + while (e.hasNext()) { + Object o = e.next(); + if(super.contains(o)) { + removeInternal(o); + if (added.remove(o) == false) + removed.add(o); + modified = true; + } + } + + // Apply updates + this.trackUpdates(modified); + + return modified; + } + + /** + * Inserts all of the elements in in the specified Collection into this + * Vector at the specified position. Shifts the element currently at + * that position (if any) and any subsequent elements to the right + * (increases their indices). The new elements will appear in the Vector + * in the order that they are returned by the specified Collection's + * iterator. + * + * @param index index at which to insert first element + * from the specified collection. + * @param c elements to be inserted into this Vector. + * @exception ArrayIndexOutOfBoundsException index out of range (index + * < 0 || index > size()). + * @see java.util.Vector + */ + public synchronized boolean addAll(int index, Collection c) { + SCOHelper.debug(_Vector, "addAll from index"); // NOI18N + + // iterate the collection and make a list of wrong elements. + Throwable[] err = new Throwable[c.size()]; + int l = 0; + + Iterator i = c.iterator(); + while (i.hasNext()) { + Object o = i.next(); + try { + SCOHelper.assertNullsAllowed(o, allowNulls); + SCOHelper.assertElementType(o, elementType); + } catch (Throwable e) { + err[l++] = e; + } + } + SCOHelper.validateResult(l, err); + + // Mark the field as dirty + this.makeDirty(); + + removed.removeAll(c); + added.addAll(c); + + boolean modified = super.addAll(index, c); + + // Apply updates + this.trackUpdates(modified); + + return modified; + } + + /** + * Retains only the elements in this Vector that are contained in the + * specified Collection. + * + * @return true if this Vector changed as a result of the call. + * @see java.util.Vector + */ + public synchronized boolean retainAll(Collection c) { + SCOHelper.debug(_Vector, "retainAll"); // NOI18N + + boolean modified = false; + java.util.ArrayList v = new java.util.ArrayList(); + + // Mark the field as dirty + this.makeDirty(); + for (Iterator iter = super.iterator(); iter.hasNext();) { + Object o = iter.next(); + if (!c.contains(o)) { + v.add(o); + if (added.remove(o) == false) { + removed.add(o); + } + modified = true; + } + } + + // Now remove the rest (stored in "v") + for (Iterator iter = v.iterator(); iter.hasNext();) { + removeInternal(iter.next()); + } + + // Apply updates + this.trackUpdates(modified); + + + return modified; + } + + /** + * Creates and returns a copy of this object. + * + * <P>Mutable Second Class Objects are required to provide a public + * clone method in order to allow for copying PersistenceCapable + * objects. In contrast to Object.clone(), this method must not throw a + * CloneNotSupportedException. + */ + public Object clone() { + SCOHelper.debug(_Vector, "clone"); // NOI18N + + Object obj = super.clone(); + if (obj instanceof SCO) { + ((SCO)obj).unsetOwner(owner, fieldNumber); + } + return obj; + } + + /** + * @see SCOCollection#reset() + */ + public void reset() { + added.clear(); + removed.clear(); + } + + /** + * @see SCOCollection#addInternal(Object o) + */ + public void addInternal(Object o) { + super.addElement(o); + } + + + /** + * @see SCOCollection#addAllInternal(Collection c) + */ + public void addAllInternal(Collection c) { + super.addAll(c); + } + + /** + * @see SCOCollection#getAdded() + */ + public Collection getAdded() { + return (Collection)added; + } + + /** + * @see SCOCollection#getRemoved() + */ + public Collection getRemoved() { + return (Collection)removed; + } + + /** + * @see SCOCollection#clearInternal() + */ + public void clearInternal() { + //Cannot call super.clear() as it internally calls removeAllElements() + // which causes marking field as dirty. + + int s = super.size() - 1; + + // Need to loop backwards to avoid resetting size of the collection + for (int i = s; i > -1; i--) { + super.removeElementAt(i); + } + + this.reset(); + } + + + /** + * @see SCOCollection#removeInternal(Object o) + */ + public void removeInternal(Object o) { + int i = super.indexOf(o); + super.remove(i); + } + + /** + * @see SCO#unsetOwner(Object owner, int fieldNumber) + */ + public void unsetOwner(Object owner, int fieldNumber) { + // Unset only if owner and fieldNumber match. + if (this.owner == owner && this.fieldNumber == fieldNumber) { + this.owner = null; + this.fieldNumber = -1; + } + } + + /** + * @see SCO#setOwner (Object owner, int fieldNumber) + */ + public void setOwner (Object owner, int fieldNumber) { + // Set only if it was not set before. + if (this.owner == null && owner instanceof StateManagerInternal) { + this.owner = (StateManagerInternal)owner; + this.fieldNumber = fieldNumber; + } + } + /** + * @see SCO#getOwner() + */ + public Object getOwner() { + return SCOHelper.getOwner(owner); + } + + /** + * @see SCO#getFieldName() + */ + public String getFieldName() { + return SCOHelper.getFieldName(owner, fieldNumber); + } + + /** + * Marks object dirty + */ + private void makeDirty() { + if (owner != null) { + owner.makeDirty(fieldNumber); // + } + } + + /** + * Apply changes + */ + private void trackUpdates(boolean modified) { + if (modified && owner != null) { + owner.trackUpdates(fieldNumber, this); + } + } + + /** + * @see SCOCollection#getElementType() { + */ + public Class getElementType() { + return elementType; + } + + /** + * @see SCOCollection#allowNulls() { + */ + public boolean allowNulls() { + return allowNulls; + } + + /** Get an iterator over the frozen elements of this collection. + * This class does not require freezing, so this method returns + * a standard iterator. + * @since 1.0.1 + * @return an iterator over the elements. + */ + public Iterator frozenIterator() { + return iterator(); + } + + /** Set the contents of this Collection from the frozen elements. + * This class does not support explicit frozen operations, and this method + * always throws an exception. + * @since 1.0.1 + * @param elements not used. + */ + public void setFrozen(Object[] elements) { + throw new JDOFatalInternalException(msg.msg("EXC_UnsupportedFreezerOperation")); //NOI18N + } + + /** Get an iterator regardless of whether the collection is frozen. + * This class does not support frozen operations and always returns + * a regular iterator. + * @since 1.0.1 + * @return an iterator over the elements. + */ + public Iterator eitherIterator() { + return iterator(); + } + +}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/sco/package.html URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/sco/package.html?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/sco/package.html (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/sco/package.html Fri Mar 18 17:02:29 2005 @@ -0,0 +1,27 @@ +<!-- + Copyright 2005 The Apache Software Foundation. + + 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. +--> + +<html> +<head> +<title>Package org.apache.jdo.impl.sco</title> +<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"/> +</head> + +<body bgcolor="#FFFFFF"> +This package contains implementation of the SCO-related interfaces. +The interfaces are defined in <a href="../../package-summary.html">org.apache.jdo.sco</a>. +</body> +</html> Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNew.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNew.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNew.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNew.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,118 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * AutoPersistentNew.java September 4, 2001 + */ + +package org.apache.jdo.impl.state; + +import java.util.BitSet; + +import javax.jdo.Transaction; + +import org.apache.jdo.state.StateManagerInternal; +import org.apache.jdo.store.StoreManager; + + +/** + * This class represents AutoPersistentNew state specific state transitions as + * requested by StateManagerImpl. This state is a result of a call to makePersistent + * on a transient instance that references this instance (persistence-by-reachability). + * + * @author Marina Vatkina + */ +class AutoPersistentNew extends PersistentNew { + + AutoPersistentNew() { + super(); + + isAutoPersistent = true; + stateType = AP_NEW; + } + + /** + * @see LifeCycleState#transitionMakePersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionMakePersistent(StateManagerImpl sm) { + return changeState(P_NEW); + } + + /** + * @see LifeCycleState#flush(BitSet loadedFields, BitSet dirtyFields, + * StoreManager srm, StateManagerImpl sm) + */ + protected LifeCycleState flush(BitSet loadedFields, BitSet dirtyFields, + StoreManager srm, StateManagerImpl sm) { + if (sm.getPersistenceManager().insideCommit()) { + // Nothing to do - state is unreachable at commit. + sm.markAsFlushed(); + return changeState(AP_PENDING); + } + + int result = srm.insert(loadedFields, dirtyFields, sm); + + switch (result) { + case StateManagerInternal.FLUSHED_COMPLETE: + // Do NOT mark as flushed - it needs to be available for possible delete + // at commit. + return changeState(AP_NEW_FLUSHED); + + case StateManagerInternal.FLUSHED_PARTIAL: + return changeState(AP_NEW_FLUSHED_DIRTY); + + case StateManagerInternal.FLUSHED_NONE: + default: + return this; + + } + } + + /** + * @see LifeCycleState#transitionFromAutoPersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionFromAutoPersistent(StateManagerImpl sm) { + sm.disconnect(); + return changeState(TRANSIENT); + } + + /** + * Differs from the generic implementation in LifeCycleState that state transitions + * to Transient and keeps all fields. Called only if state becomes not reachable. + * @see LifeCycleState#transitionCommit(boolean retainValues, StateManagerImpl sm) + */ + protected LifeCycleState transitionCommit(boolean retainValues, StateManagerImpl sm) { + sm.disconnect(); + return changeState(TRANSIENT); + } + + /** + * Differs from the generic implementation in LifeCycleState that state transitions + * to Transient and restores all fields. Called only if state becomes not reachable. + * @see LifeCycleState#transitionRollback(boolean restoreValues, StateManagerImpl sm) + */ + protected LifeCycleState transitionRollback(boolean restoreValues, StateManagerImpl sm) { + if (restoreValues) { + sm.restoreFields(); + } else { + sm.unsetSCOFields(); + } + sm.disconnect(); + return changeState(TRANSIENT); + } + +} + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNewFlushed.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNewFlushed.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNewFlushed.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNewFlushed.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,116 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * AutoPersistentNewFlushed.java September 4, 2001 + */ + +package org.apache.jdo.impl.state; + +import java.util.BitSet; + +import javax.jdo.JDOFatalInternalException; +import javax.jdo.Transaction; + +import org.apache.jdo.state.StateManagerInternal; +import org.apache.jdo.store.StoreManager; + + +/** + * This class represents AutoPersistentNewFlushed state specific state + * transitions as requested by StateManagerImpl. This state differs from + * AutoPersistentNew state as the correspondinfg instance has been flushed + * to a datastore. + * + * @author Marina Vatkina + */ +class AutoPersistentNewFlushed extends PersistentNewFlushed { + + protected AutoPersistentNewFlushed() { + super(); + + isAutoPersistent = true; + stateType = AP_NEW_FLUSHED; + } + + /** + * @see LifeCycleState#transitionMakePersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionMakePersistent(StateManagerImpl sm) { + return changeState(P_NEW_FLUSHED); + } + + /** + * @see LifeCycleState#transitionDeletePersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionDeletePersistent(StateManagerImpl sm) { + sm.preDelete(); + return changeState(P_NEW_FLUSHED_DELETED); + } + + /** + * @see LifeCycleState#transitionWriteField(StateManagerImpl sm, + * Transaction tx) + */ + protected LifeCycleState transitionWriteField(StateManagerImpl sm, + Transaction tx) { + return changeState(AP_NEW_FLUSHED_DIRTY); + } + + /** + * This is a reverse operation if reached. + * @see LifeCycleState#flush(BitSet loadedFields, BitSet dirtyFields, + * StoreManager srm, StateManagerImpl sm) + */ + protected LifeCycleState flush(BitSet loadedFields, BitSet dirtyFields, + StoreManager srm, StateManagerImpl sm) { + if (sm.getPersistenceManager().insideCommit()) { + // Need to restore state - it is unreachable at commit: + if (srm.delete(loadedFields, dirtyFields, sm) == + StateManagerInternal.FLUSHED_COMPLETE) { + + sm.markAsFlushed(); + return changeState(AP_PENDING); + } + } + return this; + } + + /** + * Differs from the generic implementation in LifeCycleState that state transitions + * to Transient and restores all fields. Called only if state becomes not reachable. + * @see LifeCycleState#transitionRollback(boolean restoreValues, StateManagerImpl sm) + */ + protected LifeCycleState transitionRollback(boolean restoreValues, StateManagerImpl sm) { + if (restoreValues) { + sm.restoreFields(); + } else { + sm.unsetSCOFields(); + } + sm.disconnect(); + return changeState(TRANSIENT); + } + + /** + * @see LifeCycleState#transitionCommit(boolean retainValues, StateManagerImpl sm) + */ + protected LifeCycleState transitionCommit(boolean retainValues, StateManagerImpl sm) { + throw new JDOFatalInternalException(msg.msg( + "EXC_InconsistentState", // NOI18N + "commit", this.toString())); // NOI18N + } +} + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNewFlushedDirty.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNewFlushedDirty.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNewFlushedDirty.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentNewFlushedDirty.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,101 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * AutoPersistentNewFlushedDirty.java September 4, 2001 + */ + +package org.apache.jdo.impl.state; + +import java.util.BitSet; + +import org.apache.jdo.state.StateManagerInternal; +import org.apache.jdo.store.StoreManager; + + +/** + * This class represents AutoPersistentNewFlushedDirty state specific state + * transitions as requested by StateManagerImpl. This state is the result + * calls: makePersistent-flush-write_field on the same instance. + * + * @author Marina Vatkina + */ +class AutoPersistentNewFlushedDirty extends PersistentNewFlushedDirty { + + protected AutoPersistentNewFlushedDirty() { + super(); + + isAutoPersistent = true; + stateType = AP_NEW_FLUSHED_DIRTY; + } + + /** + * @see LifeCycleState#transitionMakePersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionMakePersistent(StateManagerImpl sm) { + return changeState(P_NEW_FLUSHED_DIRTY); + } + + /** + * @see LifeCycleState#transitionDeletePersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionDeletePersistent(StateManagerImpl sm) { + sm.preDelete(); + return changeState(P_NEW_FLUSHED_DELETED); + } + + /** + * @see LifeCycleState#flush(BitSet loadedFields, BitSet dirtyFields, + * StoreManager srm, StateManagerImpl sm) + */ + protected LifeCycleState flush(BitSet loadedFields, BitSet dirtyFields, + StoreManager srm, StateManagerImpl sm) { + if (sm.getPersistenceManager().insideCommit()) { + // Need to restore state - it is unreachable at commit: + if (srm.delete(loadedFields, dirtyFields, sm) == + StateManagerInternal.FLUSHED_COMPLETE) { + sm.markAsFlushed(); + return changeState(AP_PENDING); + } + + } else { // flush for query + // Need to update state - it is flush for query + if (srm.update(loadedFields, dirtyFields, sm) == + StateManagerInternal.FLUSHED_COMPLETE) { + + // Do NOT mark as flushed - it needs to be processed again at commit. + return changeState(AP_NEW_FLUSHED); + } + } + return this; + } + + /** + * Differs from the generic implementation in LifeCycleState that state transitions + * to Transient and restores all fields. Called only if state becomes not reachable. + * @see LifeCycleState#transitionRollback(boolean restoreValues, StateManagerImpl sm) + */ + protected LifeCycleState transitionRollback(boolean restoreValues, StateManagerImpl sm) { + if (restoreValues) { + sm.restoreFields(); + } else { + sm.unsetSCOFields(); + } + sm.disconnect(); + return changeState(TRANSIENT); + } +} + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentPending.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentPending.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentPending.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/AutoPersistentPending.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,88 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * AutoPersistentPending.java September 6, 2001 + */ + +package org.apache.jdo.impl.state; + +import java.util.BitSet; + +import org.apache.jdo.store.StoreManager; + + +/** + * This class represents AutoPersistentPending state that is a result of a + * previous call to makePersistent on a transient instance that referenced this + * instance (persistence-by-reachability). This state represents instance + * not reachable any more. + * + * @author Marina Vatkina + */ +class AutoPersistentPending extends AutoPersistentNewFlushed { + + AutoPersistentPending() { + super(); + + stateType = AP_PENDING; + } + + /** + * @see LifeCycleState#transitionFromAutoPersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionFromAutoPersistent(StateManagerImpl sm) { + sm.disconnect(); + return changeState(TRANSIENT); + } + + /** + * This is a no-op operation if reached. + * @see LifeCycleState#flush(BitSet loadedFields, BitSet dirtyFields, + * StoreManager srm, StateManagerImpl sm) + */ + protected LifeCycleState flush(BitSet loadedFields, BitSet dirtyFields, + StoreManager srm, StateManagerImpl sm) { + return this; + } + + /** + * Differs from the generic implementation in LifeCycleState that state transitions + * to Transient and keeps all fields. Called only if state becomes not reachable. + * @see LifeCycleState#transitionCommit(boolean retainValues, StateManagerImpl sm) + */ + protected LifeCycleState transitionCommit(boolean retainValues, StateManagerImpl sm) { + sm.disconnect(); + return changeState(TRANSIENT); + } + + /** + * Differs from the generic implementation in LifeCycleState that state transitions + * to Transient and restores all fields. Called only if state becomes not reachable. + * @see LifeCycleState#transitionRollback(boolean restoreValues, StateManagerImpl sm) + */ + protected LifeCycleState transitionRollback(boolean restoreValues, StateManagerImpl sm) { + if (restoreValues) { + sm.restoreFields(); + } else { + sm.unsetSCOFields(); + } + sm.disconnect(); + return changeState(TRANSIENT); + } + +} + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/Bundle.properties URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/Bundle.properties?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/Bundle.properties (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/Bundle.properties Fri Mar 18 17:02:29 2005 @@ -0,0 +1,68 @@ +# +# Copyright 2005 The Apache Software Foundation. +# +# 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. + +# This file should conform to netbeans standards +# (http://www.netbeans.org/i18n) + +# resource bundle for the messages +# key consists of: <PREFIX_><description> +# <PREFIX_> - any valid prefix like MSG_, EXC_, etc. +# <description> - short description started with the upper case letter and used +# upper case to represent each next word. + +# XXX TBD: this message is not used: +notsupported=Operation is not supported in this release. + +# +# StateManagerImpl +# +EXC_CannotGetJDOImplHelper=A SecurityException was thrown when trying to get \ +the singleton JDOImplHelper instance. In order to get runtime metadata, you \ +must grant javax.jdo.spi.JDOPermission("getMetadata") to the codeBases \ +containing the JDO Reference Implementation (jdo.jar and jdori.jar). +EXC_CannotSetStateManager=A SecurityException was thrown when calling \ +jdoReplaceStateManager on persistence capable class instance. In order to set \ +the state manager, you must grant \ +javax.jdo.spi.JDOPermission("setStateManager") to the codeBases containing \ +the JDO Reference Implementation (jdo.jar and jdori.jar) and to the codeBase \ +containing the class files of the persistent capable classes. +EXC_PersistentInAnotherPersistenceManager=Invalid attempt to make persistent an object that is owned by a different PersistenceManager. +EXC_NotNeededByRI=Method {0} is not needed in the reference implementation and should not have been invoked. +EXC_CannotAccessModel=Cannot access JDO Model for {0}. +EXC_SCONotCloneable=An instance of class {0} is of an SCO type but is not cloneable. + +# Exceptions for SCO type validation: +EXC_WrongElementType=Element type of this tracked instance ({0}) is not assignable from type specified in the JDO Model ({1}). +EXC_WrongValueType=Value type of this tracked instance ({0}) is not assignable from type specified in the JDO Model ({1}). +EXC_WrongKeyType=Key type of this tracked instance ({0}) is not assignable from type specified in the JDO Model ({1}). + +# NOI18N +EXC_NullLifeCycle=Internal error on replacingStateManager - LifeCycle is null. +# NOI18N +EXC_NotTransitionTransient=Internal error on replacingStateManager - not transitioning to transient. +# NOI18N +EXC_SameStateManager=Internal error on replacingStateManager - same StateManager. + +# +# Lifecycle +# +EXC_DirtyInstance=Instance is dirty. +EXC_AccessDeletedField=Access to fields is not allowed for deleted instances. +# NOI18N +# In the following exception {0} is "commit" or "rollback", and {1} is Lifecycle state. +EXC_InconsistentState=Inconsistent state on {0}: {1}. +EXC_TransactionNotActive=Transaction is not active. + + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/Hollow.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/Hollow.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/Hollow.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/Hollow.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,219 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * Hollow.java March 10, 2001 + */ + +package org.apache.jdo.impl.state; + +import javax.jdo.Transaction; +import javax.jdo.JDOFatalInternalException; + +import org.apache.jdo.state.FieldManager; + +/** + * This class represents Hollow state specific state transitions as requested + * by StateManagerImpl. This state is the result of commit or rollback of a + * persistent instance when retainValues flag on the Transaction is set to + * false. + * + * @author Marina Vatkina + */ +class Hollow extends LifeCycleState { + + Hollow() { + // these flags are set only in the constructor + // and shouldn't be changed afterwards + // (cannot make them final since they are declared in superclass + // but their values are specific to subclasses) + isPersistent = true; + isTransactional = false; + isDirty = false; + isNew = false; + isDeleted = false; + + isBeforeImageUpdatable = false; + isRefreshable = false; + isFlushed = true; + + stateType = HOLLOW; + } + + /** + * @see LifeCycleState#transitionDeletePersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionDeletePersistent(StateManagerImpl sm) { + + sm.refresh(); + sm.registerTransactional(); + sm.preDelete(); + return changeState(P_DELETED); + } + + /** + * @see LifeCycleState#transitionMakeNontransactional(StateManagerImpl sm, + * Transaction tx) + */ + protected LifeCycleState transitionMakeNontransactional(StateManagerImpl sm, + Transaction tx) { + return this; + } + + /** + * @see LifeCycleState#transitionMakeTransient(StateManagerImpl sm, + Transaction tx) + */ + protected LifeCycleState transitionMakeTransient(StateManagerImpl sm, + Transaction tx) { + sm.disconnect(); + return changeState(TRANSIENT); + } + + /** + * @see LifeCycleState#transitionMakeTransactional( + * StateManagerImpl sm, Transaction tx) + */ + protected LifeCycleState transitionMakeTransactional(StateManagerImpl sm, + Transaction tx) { + + if (tx.isActive()) { + sm.registerTransactional(); + sm.refresh(); + sm.postLoad(); + + if (tx.getOptimistic()) { + sm.createBeforeImage(); + return changeState(P_CLEAN_TX); + } else { // pessimistic transaction + sm.markAsFlushed(); + return changeState(P_CLEAN); + } + } else { // transaction not active + return this; + } + } + + /** + * @see LifeCycleState#transitionReload(StateManagerImpl sm, Transaction tx) + */ + protected LifeCycleState transitionReload(StateManagerImpl sm, + Transaction tx) { + + sm.refresh(); + return this.transitionLoad(sm, tx); + } + + /** + * @see LifeCycleState#transitionRetrieve(StateManagerImpl sm, Transaction tx) + */ + protected LifeCycleState transitionRetrieve(StateManagerImpl sm, + Transaction tx) { + + sm.loadUnloaded(); + // This state behaves the same on retrieve request and reload: + return this.transitionLoad(sm, tx); + } + + /** + * @see LifeCycleState#transitionReplace(StateManagerImpl sm, + * Transaction tx, int[] fields, FieldManager fieldManager) + */ + protected LifeCycleState transitionReplace(StateManagerImpl sm, + Transaction tx, int[] fields, FieldManager fieldManager) { + + sm.replaceFields(fields, fieldManager); + return this.transitionLoad(sm, tx); + } + + /** + * @see LifeCycleState#transitionReadField(StateManagerImpl sm, + * Transaction tx) + */ + protected LifeCycleState transitionReadField(StateManagerImpl sm, + Transaction tx) { + + boolean transactionActive = tx.isActive(); + if (!tx.getNontransactionalRead()) { + assertTransaction(transactionActive); + } + + sm.postLoad(); + if (!tx.getOptimistic() && transactionActive) { + sm.registerTransactional(); + // Need to remove from non-flushed cache + sm.markAsFlushed(); + return changeState(P_CLEAN); + } + + sm.registerNonTransactional(); + return changeState(P_NON_TX); + } + + /** + * @see LifeCycleState#transitionWriteField(StateManagerImpl sm, + * Transaction tx) + */ + protected LifeCycleState transitionWriteField(StateManagerImpl sm, + Transaction tx) { + + boolean transactionActive = tx.isActive(); + if (!tx.getNontransactionalWrite()) { + assertTransaction(transactionActive); + } + + sm.postLoad(); + if(transactionActive) { + //sm.createBeforeImage(); + sm.registerTransactional(); + return changeState(P_DIRTY); + } else { + sm.registerNonTransactional(); + return changeState(P_NON_TX); + } + + } + + /** + * This state transition is invalid for the rollback. + * @see LifeCycleState#transitionRollback(boolean restoreValues, + * StateManagerImpl sm) + */ + protected LifeCycleState transitionRollback(boolean restoreValues, + StateManagerImpl sm) { + throw new JDOFatalInternalException(msg.msg( + "EXC_InconsistentState", // NOI18N + "rollback", this.toString())); // NOI18N + } + + /** + * Transitions LifeCycle state on reload or retrieve call. + */ + private LifeCycleState transitionLoad(StateManagerImpl sm, Transaction tx) { + sm.postLoad(); + if (tx.isActive() && !tx.getOptimistic()) { + sm.registerTransactional(); + // Need to remove from non-flushed cache + sm.markAsFlushed(); + + return changeState(P_CLEAN); + } else { + sm.registerNonTransactional(); + } + return changeState(P_NON_TX); + } +} + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/LifeCycleState.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/LifeCycleState.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/LifeCycleState.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/LifeCycleState.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,573 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * LifeCycleState.java March 10, 2001 + */ + +package org.apache.jdo.impl.state; + +import java.util.BitSet; + +import javax.jdo.JDOUserException; +import javax.jdo.JDOFatalInternalException; +import javax.jdo.Transaction; + +import org.apache.jdo.state.FieldManager; +import org.apache.jdo.store.StoreManager; +import org.apache.jdo.util.I18NHelper; + + +/** + * This is an abstract LifeCycleState that provides the most common implementation + * for the state transitions and most common values for the state flags. Each + * specific state overrides only necessary methods. All states are represented + * by the static array of state instances. States can only call back StateManagerImpl + * if it is passed as a parameter to a method call. States do not hold references + * to any instances and are StateManger independent. + * + * @author Marina Vatkina + */ +abstract class LifeCycleState { + + /** + * I18N message handler + */ + protected final static I18NHelper msg = + I18NHelper.getInstance("org.apache.jdo.impl.state.Bundle"); // NOI18N + + // These are state flags that are set to required valuers in specific state + protected boolean isPersistent; + protected boolean isTransactional; + protected boolean isDirty; + protected boolean isNew; + protected boolean isDeleted; + + // These are internal flags. + protected boolean isNavigable; + protected boolean isRefreshable; + protected boolean isBeforeImageUpdatable; + protected boolean isFlushed; + protected boolean isAutoPersistent = false; + + // This flag is set to true if the state corresponds to an instance + // that exists in a datastore. + protected boolean isStored = true; + + // The following flag states that merge is needed + protected boolean needMerge = true; + + protected int stateType; + + /** + * Constants to specify the life cycle state type + */ + final static protected int + TRANSIENT = 0, + HOLLOW = 1, + P_NON_TX = 2, + + P_CLEAN = 3, + P_CLEAN_TX = 4, + + P_DIRTY = 5, + P_DIRTY_FLUSHED = 6, + + P_NEW = 7, + P_NEW_FLUSHED = 8, + P_NEW_FLUSHED_DELETED = 9, + P_NEW_FLUSHED_DIRTY = 10, + P_NEW_DELETED = 11, + + P_DELETED = 12, + P_DELETED_FLUSHED = 13, + + T_CLEAN = 14, + T_DIRTY = 15, + + AP_NEW = 16, + AP_NEW_FLUSHED = 17, + AP_NEW_FLUSHED_DIRTY = 18, + AP_PENDING = 19, + + TOTAL = 20; + + private static LifeCycleState stateTypes[]; + + + // ****************************************************************** + // Initialisation stuff + // ****************************************************************** + + /** + * Static initialiser. + * Initialises the life cycle. + */ + static { + initLifeCycleState(); + } + + /** + * Initialises the objects. This class implements the "state pattern". + */ + + // This method is called (through the static initializer) + // when the LifeCycleState class or any of its subclasses is loaded. + + // It is extremely important that this method is called before any of isNew etc is called, + // and before stateType() is called !!! + + protected static void initLifeCycleState() { + stateTypes = new LifeCycleState[TOTAL]; + + stateTypes[TRANSIENT] = null; + stateTypes[T_CLEAN] = new TransientClean(); + stateTypes[T_DIRTY] = new TransientDirty(); + + stateTypes[P_CLEAN] = new PersistentClean(); + stateTypes[P_CLEAN_TX] = new PersistentCleanTransactional(); + + stateTypes[P_DIRTY] = new PersistentDirty(); + stateTypes[P_DIRTY_FLUSHED] = new PersistentDirtyFlushed(); + + stateTypes[P_NEW] = new PersistentNew(); + stateTypes[P_NEW_FLUSHED] = new PersistentNewFlushed(); + stateTypes[P_NEW_DELETED] = new PersistentNewDeleted(); + stateTypes[P_NEW_FLUSHED_DELETED] = new PersistentNewFlushedDeleted(); + stateTypes[P_NEW_FLUSHED_DIRTY] = new PersistentNewFlushedDirty(); + + stateTypes[AP_NEW] = new AutoPersistentNew(); + stateTypes[AP_NEW_FLUSHED] = new AutoPersistentNewFlushed(); + stateTypes[AP_NEW_FLUSHED_DIRTY] = new AutoPersistentNewFlushedDirty(); + stateTypes[AP_PENDING] = new AutoPersistentPending(); + + stateTypes[P_DELETED] = new PersistentDeleted(); + stateTypes[P_DELETED_FLUSHED] = new PersistentDeletedFlushed(); + + stateTypes[HOLLOW] = new Hollow(); + stateTypes[P_NON_TX] = new PersistentNonTransactional(); + } + + /** + * Returns the LifeCycleState for the state constant. + * + * @param state the state type as integer + * @return the type as LifeCycleState object + */ + protected static LifeCycleState getLifeCycleState(int state) { + return stateTypes[state]; + } + + /** + * Returns the type of the life cycle state as an int. + * + * @return the type of this life cycle state as an int. + * + */ + protected int stateType() { + return stateType; + } + + /** + * Transitions LifeCycleState on call to makeTransient. + * + * @see javax.jdo.PersistenceManager#makeTransient(Object pc) + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @return new LifeCycleState. + */ + protected LifeCycleState transitionMakeTransient(StateManagerImpl sm, + Transaction tx) { + throw new JDOUserException(msg.msg( + "EXC_DirtyInstance"), sm.getObject()); // NOI18N + } + + /** + * Transitions LifeCycleState on call to makeTransactional + * + * @see javax.jdo.PersistenceManager#makeTransactional(Object pc) + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @return new LifeCycleState. + */ + protected LifeCycleState transitionMakeTransactional(StateManagerImpl sm, + Transaction tx) { + return this; + } + + /** + * Transitions LifeCycleState on call to makeNontransactional + * + * @see javax.jdo.PersistenceManager#makeNontransactional(Object pc) + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @return new LifeCycleState. + */ + protected LifeCycleState transitionMakeNontransactional(StateManagerImpl sm, + Transaction tx) { + throw new JDOUserException(msg.msg( + "EXC_DirtyInstance"), sm.getObject()); // NOI18N + } + + + /** + * Transitions LifeCycleState on call to makePersistent + * + * @see javax.jdo.PersistenceManager#makePersistent(Object pc) + * @param sm StateManagerImpl requested the transition. + * @return new LifeCycleState. + */ + protected LifeCycleState transitionMakePersistent(StateManagerImpl sm) { + return this; + } + + /** + * Transitions LifeCycleState as a result of call to makePersistent + * of a referencing instance (persistence-by-reachability) + * + * @see javax.jdo.PersistenceManager#makePersistent(Object pc) + * @param sm StateManagerImpl requested the transition. + * @return new LifeCycleState. + */ + protected LifeCycleState transitionToAutoPersistent(StateManagerImpl sm) { + return this; + } + + /** + * Transitions LifeCycleState to transient for AutoPersistent instance + * that is not referenced anymore (persistence-by-reachability) + * + * @see javax.jdo.PersistenceManager#makePersistent(Object pc) + * @param sm StateManagerImpl requested the transition. + * @return new LifeCycleState. + */ + protected LifeCycleState transitionFromAutoPersistent(StateManagerImpl sm) { + return this; + } + + /** + * Transitions LifeCycleState on call to deletePersistent + * + * @see javax.jdo.PersistenceManager#deletePersistent(Object pc) + * @param sm StateManagerImpl requested the transition. + * @return new LifeCycleState. + */ + protected LifeCycleState transitionDeletePersistent(StateManagerImpl sm) { + return this; + } + + /** + * Transitions LifeCycleState on call to evict an instance. + * + * @see javax.jdo.PersistenceManager#evict(Object pc) + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @return new LifeCycleState. + */ + protected LifeCycleState transitionEvict(StateManagerImpl sm, Transaction tx) { + return this; + } + + /** + * Transitions LifeCycleState on call to refresh an instance. + * + * @see javax.jdo.PersistenceManager#refresh(Object pc) + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @return new LifeCycleState. + */ + protected LifeCycleState transitionRefresh(StateManagerImpl sm, Transaction tx) { + return this; + } + + /** + * Transitions LifeCycleState on call to retrieve an instance. + * + * @see javax.jdo.PersistenceManager#retrieve(Object pc) + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @return new LifeCycleState. + */ + protected LifeCycleState transitionRetrieve(StateManagerImpl sm, Transaction tx) { + return this; + } + + /** + * Transitions the lifecycle state as if the instance is retrieved from + * the datastore, but use the specified field values instead of loading + * them from the datastore. + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @param fields Indicates which fields should be replaced in the PC. + * @param fieldManager FieldManager from which the field's value should be + * @return new LifeCycleState. + */ + protected LifeCycleState transitionReplace(StateManagerImpl sm, + Transaction tx, int[] fields, FieldManager fieldManager) { + + sm.replaceUnloadedFields(fields, fieldManager); + return this; + } + + + /** + * Transitions LifeCycleState on call to reload an instance. This is the + * result of a request to validate non-transactional instance. + * + * @see javax.jdo.PersistenceManager#getObjectById(Object oid, boolean validate) + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @return new LifeCycleState. + */ + protected LifeCycleState transitionReload(StateManagerImpl sm, Transaction tx) { + return this; + } + + /** + * Transitions LifeCycleState on commit. Called by TransactionImpl.afterCompletion. + * + * @param retainValues the value of the flag in the Transaction instance + * associated with the hashing PersistenceManager + * @param sm StateManagerImpl requested the transition. + * @return new LifeCycleState. + */ + protected LifeCycleState transitionCommit(boolean retainValues, StateManagerImpl sm) { + throw new JDOFatalInternalException(msg.msg( + "EXC_InconsistentState", // NOI18N + "commit", this.toString())); // NOI18N + } + + /** + * Transitions LifeCycleState on rollback. Called by TransactionImpl.afterCompletion. + * + * @param restoreValues the value of the flag in the Transaction instance + * associated with the hashing PersistenceManager + * @param sm StateManagerImpl requested the transition. + * @return new LifeCycleState. + */ + protected LifeCycleState transitionRollback(boolean restoreValues, StateManagerImpl sm) { + int newstate; + + if (restoreValues) { + sm.restoreFields(); + newstate = P_NON_TX; + } else { + sm.clearFields(); + newstate = HOLLOW; + } + + sm.reset(); + return changeState(newstate); + + } + + /** + * Performs state specific flush operation and transitions LifeCycleState depending + * on the result. + * + * @param loadedFields BitSet of fields loaded from the database. + * @param dirtyFields BitSet of changed fields that are to be flushed and/or + * verified against those in the database, if this <code>flush</code> is within the + * context of an optimistic transaction. After return, bits will remain set + * for fields that were not flushed, and in such case the return will be + * <code>StateManagerInternal.FLUSHED_PARTIAL</code>. If the <code>flush</code> + * was not performed because of the dependency or other restrictions, the + * return will be <code>StateManagerInternal.FLUSHED_NONE</code>. If operation + * was successful, the return will be <code>StateManagerInternal.FLUSHED_COMPLETE</code>. + * @param sm StateManagerImpl requested the transition. + * @return new LifeCycleState. + */ + protected LifeCycleState flush(BitSet loadedFields, BitSet dirtyFields, + StoreManager srm, StateManagerImpl sm) { + return this; + } + + /** + * Transitions LifeCycleState on call to read a field. + * + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @return new LifeCycleState. + */ + protected LifeCycleState transitionReadField(StateManagerImpl sm, Transaction tx) { + assertTransaction(tx.isActive()); + return this; + } + + /** + * Transitions LifeCycleState on call to write a field. + * + * @param sm StateManagerImpl requested the transition. + * @param tx Transaction associated with the hashing PersistenceManager + * @return new LifeCycleState. + */ + protected LifeCycleState transitionWriteField(StateManagerImpl sm, Transaction tx) { + assertTransaction(tx.isActive()); + return this; + } + + /** + * Asserts that current transaction is active. + * + * @throws JDOUserException if transaction is not active + * @param transactionActive true if the current transaction is active + */ + protected void assertTransaction(boolean transactionActive) { + if (!transactionActive) { + throw new JDOUserException(msg.msg( + "EXC_TransactionNotActive")); // NOI18N + } + } + + /***************************************************************/ + /************** Methods that return values for flags ***********/ + /***************************************************************/ + + /** + * Return whether the object state is persistent. + */ + protected boolean isPersistent() { + return isPersistent; + } + + /** + * Return whether the object state is transactional. + */ + protected boolean isTransactional() { + return isTransactional; + } + + /** + * Return whether the object state is dirty, that is, the object has been + * changed (created, updated, deleted) in this Tx. + */ + protected boolean isDirty() { + return isDirty; + } + + /** + * Return whether the state represents a newly created object. + */ + protected boolean isNew() { + return isNew; + } + + /** + * Return whether the state represents a deleted object. + */ + protected boolean isDeleted() { + return isDeleted; + } + + /** + * Return whether the object can dynamically navigate to fields that are + * not present. + */ + protected boolean isNavigable() { + return isNavigable; + } + + /** + * Return whether the object can be refreshed from the datastore. + */ + protected boolean isRefreshable() { + return isRefreshable; + } + + /** + * Return whether the beforeImage can be updated. + */ + protected boolean isBeforeImageUpdatable() { + return isBeforeImageUpdatable; + } + + /** + * Return whether the object has been flushed to the datastore. + */ + protected boolean isFlushed() { + return isFlushed; + } + + /** + * Return whether the object state is persistent by reachabilty only. + */ + protected boolean isAutoPersistent() { + return isAutoPersistent; + } + + /** + * Return whether the object is stored in the datastore. + */ + protected boolean isStored() { + return isStored; + } + + /** + * Return whether the merge is needed. + */ + protected boolean needMerge() { + return needMerge; + } + + /*************************************************************/ + /********************* Helper methods ************************/ + /*************************************************************/ + + /** + * Changes Life Cycle State. + * + * @return new LifeCycleState. + */ + protected LifeCycleState changeState(int newStateType) { + LifeCycleState lc = stateTypes[newStateType]; + return lc; + } + + public String toString() { + switch (stateType) { + case HOLLOW: return "HOLLOW"; // NOI18N + case P_NON_TX: return "P_NON_TX"; // NOI18N + + case T_CLEAN: return "T_CLEAN"; // NOI18N + case T_DIRTY: return "T_DIRTY"; // NOI18N + + case P_CLEAN: return "P_CLEAN"; // NOI18N + case P_CLEAN_TX: return "P_CLEAN_TX"; // NOI18N + + case P_DIRTY: return "P_DIRTY"; // NOI18N + case P_DIRTY_FLUSHED: return "P_DIRTY_FLUSHED"; // NOI18N + + case P_NEW: return "P_NEW"; // NOI18N + case P_NEW_FLUSHED: return "P_NEW_FLUSHED"; // NOI18N + case P_NEW_FLUSHED_DELETED: return "P_NEW_FLUSHED_DELETED"; // NOI18N + case P_NEW_FLUSHED_DIRTY: return "P_NEW_FLUSHED_DIRTY"; // NOI18N + case P_NEW_DELETED: return "P_NEW_DELETED"; // NOI18N + + case AP_NEW: return "AP_NEW"; // NOI18N + case AP_NEW_FLUSHED: return "AP_NEW_FLUSHED"; // NOI18N + case AP_NEW_FLUSHED_DIRTY: return "AP_NEW_FLUSHED_DIRTY"; // NOI18N + case AP_PENDING: return "AP_PENDING"; // NOI18N + + case P_DELETED: return "P_DELETED"; // NOI18N + case P_DELETED_FLUSHED: return "P_DELETED_FLUSHED"; // NOI18N + } + + return null; + } + +} + + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentClean.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentClean.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentClean.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentClean.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,148 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * PersistentClean.java March 10, 2001 + */ + +package org.apache.jdo.impl.state; + +import javax.jdo.Transaction; + +/** + * This class represents PersistentClean state specific state transitions as + * requested by StateManagerImpl. This state is the result of any of the + * following operations: + * - read field in an active datastore transaction; + * - makeTransactional call on a PersistentNonTransactional instance; + * - refresh of a PersistentDirty instance in an active datastore transaction. + * + * @author Marina Vatkina + */ +class PersistentClean extends LifeCycleState { + + PersistentClean() { + // these flags are set only in the constructor + // and shouldn't be changed afterwards + // (cannot make them final since they are declared in superclass + // but their values are specific to subclasses) + isPersistent = true; + isTransactional = true; + isDirty = false; + isNew = false; + isDeleted = false; + + isFlushed = true; + isNavigable = true; + isRefreshable = true; + isBeforeImageUpdatable = false; + + stateType = P_CLEAN; + } + + /** + * @see LifeCycleState#transitionDeletePersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionDeletePersistent(StateManagerImpl sm) { + sm.registerTransactional(); + sm.preDelete(); + return changeState(P_DELETED); + } + + /** + * @see LifeCycleState#transitionMakeNontransactional(StateManagerImpl sm, + * Transaction tx) + */ + protected LifeCycleState transitionMakeNontransactional(StateManagerImpl sm, + Transaction tx) { + sm.registerNonTransactional(); + return changeState(P_NON_TX); + } + + /** + * @see LifeCycleState#transitionMakeTransient(StateManagerImpl sm, + * Transaction tx) + */ + protected LifeCycleState transitionMakeTransient(StateManagerImpl sm, + Transaction tx) { + sm.disconnect(); + return changeState(TRANSIENT); + } + + /** + * @see LifeCycleState#transitionEvict(StateManagerImpl sm, Transaction tx) + */ + protected LifeCycleState transitionEvict(StateManagerImpl sm, Transaction tx) { + sm.clearFields(); + sm.reset(); + sm.registerNonTransactional(); + return changeState(HOLLOW); + } + + /** + * @see LifeCycleState#transitionRetrieve(StateManagerImpl sm, Transaction tx) + */ + protected LifeCycleState transitionRetrieve(StateManagerImpl sm, + Transaction tx) { + + sm.loadUnloaded(); + return this; + } + + /** + * @see LifeCycleState#transitionWriteField(StateManagerImpl sm, Transaction tx) + */ + protected LifeCycleState transitionWriteField(StateManagerImpl sm, + Transaction tx) { + + int newState; + boolean transactionActive = tx.isActive(); + + if (transactionActive) { + // This is the first write request: prepare BeforeImage + sm.createBeforeImage(); + sm.registerTransactional(); + newState = P_DIRTY; + + } else { + if (!tx.getNontransactionalWrite()) { + assertTransaction(false); + } + sm.registerNonTransactional(); + newState = P_NON_TX; + } + return changeState(newState); + } + + /** + * @see LifeCycleState#transitionCommit(boolean retainValues, StateManagerImpl sm) + */ + protected LifeCycleState transitionCommit(boolean retainValues, StateManagerImpl sm) { + int newstate; + + if (retainValues) { + sm.replaceSCOFields(); + newstate = P_NON_TX; + } else { + sm.clearFields(); + newstate = HOLLOW; + } + + sm.reset(); + return changeState(newstate); + } +} + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentCleanTransactional.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentCleanTransactional.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentCleanTransactional.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentCleanTransactional.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,70 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * PersistentCleanTransactional.java August 13, 2001 + */ + +package org.apache.jdo.impl.state; + +import java.util.BitSet; + +import javax.jdo.Transaction; + +import org.apache.jdo.state.StateManagerInternal; +import org.apache.jdo.store.StoreManager; + + +/** + * This class represents PersistentCleanTransactional state specific state + * transitions as requested by StateManagerImpl. This state differs from + * PersistentClean in that it is the result of call to makeTransactional + * of a PersistentNonTransactional instance in an active optimistic transaction. + * This state verifies itself at flush. + * + * @author Marina Vatkina + */ +class PersistentCleanTransactional extends PersistentClean { + + PersistentCleanTransactional() { + isFlushed = false; + stateType = P_CLEAN_TX; + } + + /** + * @see LifeCycleState#transitionWriteField(StateManagerImpl sm, + * Transaction tx) + */ + protected LifeCycleState transitionWriteField(StateManagerImpl sm, + Transaction tx) { + return changeState(P_DIRTY); + } + + /** + * @see LifeCycleState#flush(BitSet loadedFields, BitSet dirtyFields, + * StoreManager srm, StateManagerImpl sm) + */ + protected LifeCycleState flush(BitSet loadedFields, BitSet dirtyFields, + StoreManager srm, StateManagerImpl sm) { + if (srm.verifyFields(loadedFields, dirtyFields, sm) == + StateManagerInternal.FLUSHED_COMPLETE) { + sm.markAsFlushed(); + return changeState(P_CLEAN); + } + return this; + } + +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDeleted.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDeleted.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDeleted.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDeleted.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,110 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * PersistentDeleted.java March 10, 2001 + */ + +package org.apache.jdo.impl.state; + +import java.util.BitSet; + +import javax.jdo.Transaction; +import javax.jdo.JDOUserException; + +import org.apache.jdo.state.StateManagerInternal; +import org.apache.jdo.store.StoreManager; + + +/** + * This class represents PersistentDeleted state specific state transitions as requested + * by StateManagerImpl. This state is the result of a call to deletePersistent of a + * persistent instance. + * + * @author Marina Vatkina + */ +class PersistentDeleted extends LifeCycleState { + + PersistentDeleted() { + // these flags are set only in the constructor + // and shouldn't be changed afterwards + // (cannot make them final since they are declared in superclass + // but their values are specific to subclasses) + isPersistent = true; + isTransactional = true; + isDirty = true; + isNew = false; + isDeleted = true; + + isNavigable = false; + isRefreshable = true; + isBeforeImageUpdatable = false; + isFlushed = false; + + // The following flag does not allow merge + needMerge = false; + + stateType = P_DELETED; + } + + + /** + * @see LifeCycleState#transitionReadField(StateManagerImpl sm, + * Transaction tx) + * @throws JDOUserException on read access + */ + protected LifeCycleState transitionReadField(StateManagerImpl sm, + Transaction tx) { + // Cannot read a deleted object + throw new JDOUserException(msg.msg( + "EXC_AccessDeletedField")); // NOI18N + } + + /** + * @see LifeCycleState#transitionWriteField(StateManagerImpl sm, + * Transaction tx) + * @throws JDOUserException on write access + */ + protected LifeCycleState transitionWriteField(StateManagerImpl sm, + Transaction tx) { + // Cannot update a deleted object + throw new JDOUserException(msg.msg( + "EXC_AccessDeletedField")); // NOI18N + } + + /** + * @see LifeCycleState#flush(BitSet loadedFields, BitSet dirtyFields, + * StoreManager srm, StateManagerImpl sm) + */ + protected LifeCycleState flush(BitSet loadedFields, BitSet dirtyFields, + StoreManager srm, StateManagerImpl sm) { + if (srm.delete(loadedFields, dirtyFields, sm) == + StateManagerInternal.FLUSHED_COMPLETE) { + sm.markAsFlushed(); + return changeState(P_DELETED_FLUSHED); + } + return this; + } +} + + + + + + + + + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDeletedFlushed.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDeletedFlushed.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDeletedFlushed.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDeletedFlushed.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,58 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * PersistentDeletedFlushed.java March 10, 2001 + */ + +package org.apache.jdo.impl.state; + +/** + * This class represents PersistentDeletedFlushed state specific state + * transitions as requested by StateManagerImpl. This state differs from + * PersistentDeleted in that it is the result of a flush operation on + * a deleted instance. + * + * @author Marina Vatkina + */ +class PersistentDeletedFlushed extends PersistentDeleted { + + protected PersistentDeletedFlushed() { + super(); + isFlushed = true; + isStored = false; + + stateType = P_DELETED_FLUSHED; + } + + /** + * @see LifeCycleState#transitionCommit(boolean retainValues, StateManagerImpl sm) + */ + protected LifeCycleState transitionCommit(boolean retainValues, StateManagerImpl sm) { + sm.clearFields(); + sm.disconnect(); + return changeState(TRANSIENT); + } +} + + + + + + + + + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDirty.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDirty.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDirty.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/state/PersistentDirty.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,110 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * 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. + */ + +/* + * PersistentDirty.java March 10, 2001 + */ + +package org.apache.jdo.impl.state; + +import java.util.BitSet; + +import javax.jdo.Transaction; +import javax.jdo.JDOFatalInternalException; + +import org.apache.jdo.state.StateManagerInternal; +import org.apache.jdo.store.StoreManager; + + +/** + * This class represents PersistentDirty state specific state transitions as requested + * by StateManagerImpl. This state is a result of a write operation on a persistent + * instance. + * + * @author Marina Vatkina + */ +class PersistentDirty extends LifeCycleState { + + PersistentDirty() { + // these flags are set only in the constructor + // and shouldn't be changed afterwards + // (cannot make them final since they are declared in superclass + // but their values are specific to subclasses) + isPersistent = true; + isTransactional = true; + isDirty = true; + isNew = false; + isDeleted = false; + + isNavigable = true; + isRefreshable = true; + isBeforeImageUpdatable = true; + isFlushed = false; + + stateType = P_DIRTY; + } + + /** + * @see LifeCycleState#transitionDeletePersistent(StateManagerImpl sm) + */ + protected LifeCycleState transitionDeletePersistent(StateManagerImpl sm) { + sm.preDelete(); + return changeState(P_DELETED); + } + + /** + * @see LifeCycleState#transitionRefresh(StateManagerImpl sm, Transaction tx) + */ + protected LifeCycleState transitionRefresh(StateManagerImpl sm, + Transaction tx) { + sm.unsetBeforeImage(); + sm.refresh(); + + if (tx.isActive() && !tx.getOptimistic()) { + return changeState(P_CLEAN); + } else { + sm.registerNonTransactional(); + } + return changeState(P_NON_TX); + } + + /** + * @see LifeCycleState#transitionRetrieve(StateManagerImpl sm, Transaction tx) + */ + protected LifeCycleState transitionRetrieve(StateManagerImpl sm, + Transaction tx) { + + sm.loadUnloaded(); + return this; + } + + /** + * @see LifeCycleState#flush(BitSet loadedFields, BitSet dirtyFields, + * StoreManager srm, StateManagerImpl sm) + */ + protected LifeCycleState flush(BitSet loadedFields, BitSet dirtyFields, + StoreManager srm, StateManagerImpl sm) { + + if (srm.update(loadedFields, dirtyFields, sm) == + StateManagerInternal.FLUSHED_COMPLETE) { + + sm.markAsFlushed(); + return changeState(P_DIRTY_FLUSHED); + } + + return this; + } +}
