db-jdo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From m..@apache.org
Subject svn commit: r158176 [46/79] - in incubator/jdo/trunk/ri11: ./ src/ src/conf/ src/java/ src/java/org/ src/java/org/apache/ src/java/org/apache/jdo/ src/java/org/apache/jdo/ejb/ src/java/org/apache/jdo/enhancer/ src/java/org/apache/jdo/impl/ src/java/org/apache/jdo/impl/enhancer/ src/java/org/apache/jdo/impl/enhancer/classfile/ src/java/org/apache/jdo/impl/enhancer/core/ src/java/org/apache/jdo/impl/enhancer/generator/ src/java/org/apache/jdo/impl/enhancer/meta/ src/java/org/apache/jdo/impl/enhancer/meta/model/ src/java/org/apache/jdo/impl/enhancer/meta/prop/ src/java/org/apache/jdo/impl/enhancer/meta/util/ src/java/org/apache/jdo/impl/enhancer/util/ src/java/org/apache/jdo/impl/fostore/ src/java/org/apache/jdo/impl/jdoql/ src/java/org/apache/jdo/impl/jdoql/jdoqlc/ src/java/org/apache/jdo/impl/jdoql/scope/ src/java/org/apache/jdo/impl/jdoql/tree/ src/java/org/apache/jdo/impl/model/ src/java/org/apache/jdo/impl/model/java/ src/java/org/apache/jdo/impl/model/java/runtime/ src/java/org/apache/jdo/impl/model/jdo/ src/java/org/apache/jdo/impl/model/jdo/caching/ src/java/org/apache/jdo/impl/model/jdo/util/ src/java/org/apache/jdo/impl/model/jdo/xml/ src/java/org/apache/jdo/impl/pm/ src/java/org/apache/jdo/impl/sco/ src/java/org/apache/jdo/impl/state/ src/java/org/apache/jdo/jdoql/ src/java/org/apache/jdo/jdoql/tree/ src/java/org/apache/jdo/model/ src/java/org/apache/jdo/model/java/ src/java/org/apache/jdo/model/jdo/ src/java/org/apache/jdo/pm/ src/java/org/apache/jdo/sco/ src/java/org/apache/jdo/state/ src/java/org/apache/jdo/store/ src/java/org/apache/jdo/util/ test/ test/conf/ test/enhancer/ test/enhancer/sempdept/ test/enhancer/sempdept/src/ test/enhancer/sempdept/src/empdept/ test/fsuid2/ test/fsuid2/org/ test/fsuid2/org/apache/ test/fsuid2/org/apache/jdo/ test/fsuid2/org/apache/jdo/pc/ test/java/ test/java/org/ test/java/org/apache/ test/java/org/apache/jdo/ test/java/org/apache/jdo/impl/ test/java/org/apache/jdo/impl/fostore/ test/java/org/apache/jdo/pc/ test/java/org/apache/jdo/pc/appid/ test/java/org/apache/jdo/pc/empdept/ test/java/org/apache/jdo/pc/serializable/ test/java/org/apache/jdo/pc/xempdept/ test/java/org/apache/jdo/test/ test/java/org/apache/jdo/test/query/ test/java/org/apache/jdo/test/util/ test/jdo/ test/jdo/org/ test/jdo/org/apache/ test/jdo/org/apache/jdo/ test/jdo/org/apache/jdo/pc/ test/jdo/org/apache/jdo/pc/appid/ test/jdo/org/apache/jdo/pc/empdept/ test/jdo/org/apache/jdo/pc/serializable/ test/jdo/org/apache/jdo/pc/xempdept/ xdocs/
Date Sat, 19 Mar 2005 01:06:09 GMT
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 &lt; 0 || index &gt;= size()).
+     * @exception IllegalArgumentException fromIndex &gt; 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 &lt; 0 || index &gt; 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
+     *            &lt; 0 || index &gt;= 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
+     *            &lt; 0 || index &gt; 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;
+    }
+}



Mime
View raw message