/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.openjpa.kernel;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.BitSet;
import java.util.Collection;
import java.util.Date;
import java.util.Map;
import org.apache.openjpa.enhance.PersistenceCapable;
import org.apache.openjpa.meta.FieldMetaData;
import org.apache.openjpa.meta.JavaTypes;
import org.apache.openjpa.util.ProxyManager;
/**
* FieldManager type used to store information for rollback.
*
* @author Abe White
*/
public class SaveFieldManager
extends ClearFieldManager
implements Serializable {
private final StateManagerImpl _sm;
private final BitSet _unloaded;
private BitSet _saved = null;
private int[] _copyField = null;
private transient PersistenceCapable _state = null;
// used to track field value during store/fetch cycle
private Object _field = null;
/**
* Constructor. Provide {@link StateManagerImpl} of instance to save.
*/
SaveFieldManager(StateManagerImpl sm, PersistenceCapable pc, BitSet dirty) {
_sm = sm;
_state = pc;
// if instance is new or transient all fields will be marked dirty even
// though they have their original values, so we can restore them;
// otherwise, we need to record already-dirty persistent fields as
// ones we won't be able to restore
FieldMetaData[] fields = _sm.getMetaData().getFields();
if (_sm.isNew() || !_sm.isPersistent() || dirty == null)
_unloaded = new BitSet(fields.length);
else {
_unloaded = (BitSet) dirty.clone();
for (int i = 0; i < fields.length; i++)
if (fields[i].getManagement() != fields[i].MANAGE_PERSISTENT)
_unloaded.clear(i);
}
}
/**
* Return the persistence capable copy holding the rollback field values.
*/
public PersistenceCapable getState() {
return _state;
}
/**
* Return the currently-loaded fields that will be unloaded after rollback.
*/
public BitSet getUnloaded() {
return _unloaded;
}
/**
* Save the given field. If this method returns true, then you need
* to use this field manager to replace the given field in the instance
* returned by {@link #getState}.
*/
public boolean saveField(int field) {
// if not loaded we can't save orig value; mark as unloaded on rollback
if (_sm.getLoaded() != null && !_sm.getLoaded().get(field)) {
_unloaded.set(field);
return false;
}
// already saved?
if (_saved != null && _saved.get(field))
return false;
FieldMetaData fmd = _sm.getMetaData().getField(field);
boolean mutable = false;
switch (fmd.getDeclaredTypeCode()) {
case JavaTypes.DATE:
case JavaTypes.ARRAY:
case JavaTypes.COLLECTION:
case JavaTypes.MAP:
case JavaTypes.OBJECT:
mutable = true;
}
// if this is not an inverse field and the proper restore flag is
// not set, skip it
if (_sm.getBroker().getInverseManager() == null
|| fmd.getInverseMetaDatas().length == 0) {
// use sm's restore directive, not broker's
int restore = _sm.getBroker().getRestoreState();
if (restore == RestoreState.RESTORE_NONE
|| (mutable && restore == RestoreState.RESTORE_IMMUTABLE)) {
_unloaded.set(field);
return false;
}
}
// prepare to save the field
if (_state == null)
_state = _sm.getPersistenceCapable().pcNewInstance(_sm, true);
if (_saved == null)
_saved = new BitSet(_sm.getMetaData().getFields().length);
_saved.set(field);
// if mutable, return true to indicate that the field needs to be
// copied by providing and replacing it using this field manager
if (mutable)
return true;
// immutable fields can just be copied over
if (_copyField == null)
_copyField = new int[1];
_copyField[0] = field;
getState().pcCopyFields(_sm.getPersistenceCapable(), _copyField);
return false;
}
/**
* Restore the given field. If this method returns true, then you need
* to use this field manager to replace the given field in the state
* manager's instance.
*/
public boolean restoreField(int field) {
// if the given field needs to be unloaded, return true so that it gets
// replaced with a default value
if (_unloaded.get(field))
return true;
// if the field was not saved, it must not have gotten dirty; just
// return false so that the current value is kept
if (_saved == null || !_saved.get(field))
return false;
// copy the saved field over
if (_copyField == null)
_copyField = new int[1];
_copyField[0] = field;
_sm.getPersistenceCapable().pcCopyFields(getState(), _copyField);
return false;
}
/**
* Compare the given field.
* @return <code>true</code> if the field is the same in the current
* state and in the saved state; otherwise, <code>false</code>.
*/
public boolean isFieldEqual(int field, Object current) {
// if the field is not available, assume that it has changed.
if (_saved == null || !_saved.get(field))
return false;
if (!(getState().pcGetStateManager() instanceof StateManagerImpl))
return false;
StateManagerImpl sm = (StateManagerImpl) getState().pcGetStateManager();
SingleFieldManager single = new SingleFieldManager(sm, sm.getBroker());
sm.provideField(getState(), single, field);
Object old = single.fetchObjectField(field);
return current == old || current != null && current.equals(old);
}
public Object fetchObjectField(int field) {
// return the copied field during save, or a null value during restore
return _field;
}
public void storeObjectField(int field, Object curVal) {
// copy mutable fields
ProxyManager proxy = _sm.getBroker().getConfiguration().
getProxyManagerInstance();
FieldMetaData fmd = _sm.getMetaData().getField(field);
switch (fmd.getDeclaredTypeCode()) {
case JavaTypes.ARRAY:
_field = proxy.copyArray(curVal);
break;
case JavaTypes.COLLECTION:
_field = proxy.copyCollection((Collection) curVal);
break;
case JavaTypes.MAP:
_field = proxy.copyMap((Map) curVal);
break;
case JavaTypes.DATE:
_field = proxy.copyDate((Date) curVal);
break;
case JavaTypes.OBJECT:
_field = proxy.copyCustom(curVal);
if (_field == null)
_field = curVal;
break;
default:
_field = curVal;
}
// if we couldn't get a copy of the sco, act like it wasn't saved
if (curVal != null && _field == null) {
_unloaded.set(field);
_saved.clear(field);
}
}
private void writeObject(ObjectOutputStream oos) throws IOException {
oos.defaultWriteObject();
_sm.writePC(oos, _state);
}
private void readObject(ObjectInputStream ois)
throws IOException, ClassNotFoundException {
ois.defaultReadObject();
_state = _sm.readPC(ois);
}
}