package org.apache.ojb.odmg;
/* Copyright 2002-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.
*/
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.ClassUtils;
import org.apache.ojb.broker.Identity;
import org.apache.ojb.broker.IdentityFactory;
import org.apache.ojb.broker.OJBRuntimeException;
import org.apache.ojb.broker.PersistenceBrokerInternal;
import org.apache.ojb.broker.core.proxy.CollectionProxy;
import org.apache.ojb.broker.core.proxy.CollectionProxyDefaultImpl;
import org.apache.ojb.broker.core.proxy.CollectionProxyListener;
import org.apache.ojb.broker.core.proxy.ProxyHelper;
import org.apache.ojb.broker.metadata.CollectionDescriptor;
import org.apache.ojb.broker.metadata.FieldType;
import org.apache.ojb.broker.metadata.ObjectReferenceDescriptor;
import org.apache.ojb.broker.util.BrokerHelper;
import org.apache.ojb.broker.util.logging.Logger;
import org.apache.ojb.broker.util.logging.LoggerFactory;
/**
* This class encapsulates classes used to take persistence capable object
* state snapshoot and to detect changed fields or references.
*
* @version $Id: Image.java,v 1.1.2.2 2005/12/21 22:29:21 tomdz Exp $
*/
public abstract class Image
{
static Logger log = LoggerFactory.getLogger(Image.class);
private long timestamp = System.currentTimeMillis();
private Image()
{
}
boolean illegalImageComparison(Image oldImage)
{
return timestamp < oldImage.timestamp;
}
public abstract void cleanup(boolean reuse);
public abstract boolean modified(Image other);
abstract void referenceProcessing(Image oldImage);
public void performReferenceDetection(Image oldImage)
{
if(illegalImageComparison(oldImage))
{
throw new ImageException("The specified Image object is newer than current one, wrong Image order!");
}
referenceProcessing(oldImage);
}
//===================================================================
// inner class
//===================================================================
public static class MultipleRef extends Image implements CollectionProxyListener
{
static final int IS_NORMAL_OBJECT = 11;
static final int IS_MATERIALIZED_PROXY = 13;
static final int IS_UNMATERIALIZED_PROXY = 17;
private ImageListener listener;
private final CollectionDescriptor cod;
private final Object collectionOrArray;
private Map references;
private int status;
private boolean hasTransientIdentity;
private boolean isRefreshed;
public MultipleRef(ImageListener listener, CollectionDescriptor cod, Object collectionOrArray)
{
this.listener = listener;
this.cod = cod;
this.collectionOrArray = collectionOrArray;
this.isRefreshed = true;
this.hasTransientIdentity = false;
this.references = Collections.EMPTY_MAP;
init();
}
private void init()
{
CollectionProxy colProxy = ProxyHelper.getCollectionProxy(collectionOrArray);
if(colProxy != null)
{
if(colProxy.isLoaded())
{
status = IS_MATERIALIZED_PROXY;
/*
TODO: avoid this cast
e.g. change CollectionProxy interface - CollectionProxy should
extend Collection to support Iterator
*/
handleReferencedObjects(((Collection) colProxy).iterator());
}
else
{
status = IS_UNMATERIALIZED_PROXY;
if(log.isDebugEnabled()) log.debug("Unmaterialized proxy collection, use proxy listener");
colProxy.addListener(this);
}
}
else
{
status = IS_NORMAL_OBJECT;
if(collectionOrArray != null)
{
Iterator it = BrokerHelper.getCollectionIterator(collectionOrArray);
handleReferencedObjects(it);
}
}
}
void handleReferencedObjects(Iterator it)
{
if(it == null) return;
references = new HashMap();
if(log.isDebugEnabled()) log.debug("Handle collection references");
IdentityFactory idFac = listener.getBroker().serviceIdentity();
Identity oid;
Object obj;
while(it.hasNext())
{
obj = it.next();
oid = idFac.buildIdentity(obj);
if(!hasTransientIdentity && oid.isTransient())
{
hasTransientIdentity = true;
}
references.put(oid, obj);
}
}
public void cleanup(boolean reuse)
{
if(log.isDebugEnabled()) log.debug("Cleanup collection image, reuse=" + reuse);
if(reuse)
{
isRefreshed = false;
}
else
{
if(status == IS_UNMATERIALIZED_PROXY)
{
CollectionProxy colProxy = ProxyHelper.getCollectionProxy(collectionOrArray);
if(colProxy != null)
{
colProxy.removeListener(this);
}
}
}
}
void referenceProcessing(Image oldImage)
{
MultipleRef oldRefs = (MultipleRef) oldImage;
if(incommensurableProxies(oldRefs))
{
if(isUnmaterializedProxy()) handleReferencedObjects(BrokerHelper.getCollectionIterator(collectionOrArray));
if(oldRefs.isUnmaterializedProxy()) oldRefs.handleReferencedObjects(BrokerHelper.getCollectionIterator(oldRefs.collectionOrArray));
}
if(!isRefreshed) refreshIdentities();
if(!oldRefs.isRefreshed) oldRefs.refreshIdentities();
// find deleted reference objects
if(oldRefs.references.size() > 0)
{
Iterator oldIter = oldRefs.references.entrySet().iterator();
while(oldIter.hasNext())
{
Map.Entry entry = (Map.Entry) oldIter.next();
Identity oldOid = (Identity) entry.getKey();
/*
search for deleted objects: if in the new image an object
from the old image is not contained, we found a deleted object
*/
if(!isUnmaterializedProxy() && !containsReference(oldOid))
{
listener.deletedXToN(cod, entry.getValue(), oldOid);
}
}
}
// find new reference objects
if(references.size() > 0)
{
Iterator newIter = references.entrySet().iterator();
while(newIter.hasNext())
{
Map.Entry entry = (Map.Entry) newIter.next();
Identity newOid = (Identity) entry.getKey();
/*
search for added objects: if in the old image an object
from the new image is not contained, we found a added object
*/
if(!oldRefs.containsReference(newOid))
{
listener.addedXToN(cod, entry.getValue(), newOid);
}
}
}
}
/**
* To detect deleted (added) collection objects it's necessary iterate over the old (new) image collection.
* If the old (new) image collection is a unmaterialized proxy we have to check if the new (old) image collection
* is the same proxy instance or not.
* E.g. if the user exchange one another the unmaterialized proxy collection objects of two main objects,
* then both proxy need to be materialized to assign the changed FK field values.
*/
private boolean incommensurableProxies(MultipleRef oldImage)
{
boolean result = false;
// deleted objects
if(oldImage.isUnmaterializedProxy() || isUnmaterializedProxy())
{
result = !collectionOrArray.equals(oldImage.collectionOrArray);
}
return result;
}
private void refreshIdentities()
{
// if no transient identities are used, nothing to do
if(hasTransientIdentity && references.size() > 0)
{
hasTransientIdentity = false;
// we need independent key list from Map
List list = new ArrayList(references.keySet());
IdentityFactory idFac = listener.getBroker().serviceIdentity();
Identity oid, newOid;
Object obj;
for(int i = 0; i < list.size(); i++)
{
oid = (Identity) list.get(i);
if(oid.isTransient())
{
obj = references.remove(oid);
newOid = idFac.buildIdentity(obj);
references.put(newOid, obj);
if(!hasTransientIdentity && oid.isTransient())
{
hasTransientIdentity = true;
}
}
}
isRefreshed = true;
}
}
/**
* Always return 'false', because changed 1:n or m:n references do not
* affect the main object.
*/
public boolean modified(Image other)
{
return false;
}
boolean containsReference(Identity oid)
{
if(!isRefreshed) refreshIdentities();
return references.containsKey(oid);
}
Map getIdentityReferenceObjectMap()
{
if(!isRefreshed) refreshIdentities();
return references;
}
boolean isMaterializedProxy()
{
return status == IS_MATERIALIZED_PROXY;
}
boolean isUnmaterializedProxy()
{
return status == IS_UNMATERIALIZED_PROXY;
}
// CollectionProxy Listener methods
//---------------------------------
public void beforeLoading(CollectionProxyDefaultImpl colProxy)
{
//noop
}
public void afterLoading(CollectionProxyDefaultImpl colProxy)
{
if(status == IS_UNMATERIALIZED_PROXY)
{
status = IS_MATERIALIZED_PROXY;
handleReferencedObjects(colProxy.iterator());
colProxy.removeListener(this);
}
}
public String toString()
{
return ClassUtils.getShortClassName(this.getClass()) + "[references-size="
+ (references != null ? "" + references.size() : "undefined") + "]";
}
}
//===================================================================
// inner class
//===================================================================
public static class SingleRef extends Image
{
private Object referenceObjOrProxy;
private Identity oid = null;
private final ImageListener listener;
private final ObjectReferenceDescriptor ord;
public SingleRef(ImageListener listener, ObjectReferenceDescriptor ord, Object reference)
{
this.listener = listener;
this.ord = ord;
this.referenceObjOrProxy = reference;
}
public void cleanup(boolean reuse)
{
if(!reuse)
{
referenceObjOrProxy = null;
}
}
void referenceProcessing(Image oldImage)
{
SingleRef oldRef = (SingleRef) oldImage;
boolean isSame = getReferenceObjectOrProxy() == oldRef.getReferenceObjectOrProxy();
if(!isSame)
{
Identity newOid = getIdentity();
Identity oldOid = oldRef.getIdentity();
if(newOid == null)
{
if(oldOid != null)
{
listener.deletedOneToOne(ord, oldRef.getReferenceObjectOrProxy(), oldOid, true);
}
}
else
{
if(oldOid == null)
{
listener.addedOneToOne(ord, getReferenceObjectOrProxy(), newOid);
}
else
{
if(!newOid.equals(oldOid))
{
listener.deletedOneToOne(ord, oldRef.getReferenceObjectOrProxy(), oldOid, false);
listener.addedOneToOne(ord, getReferenceObjectOrProxy(), newOid);
}
}
}
}
}
public Object getReferenceObjectOrProxy()
{
return referenceObjOrProxy;
}
private Identity getIdentity()
{
if(oid == null || oid.isTransient())
{
if(referenceObjOrProxy != null)
{
oid = listener.getBroker().serviceIdentity().buildIdentity(referenceObjOrProxy);
}
}
return oid;
}
/**
* If a 1:1 reference has changed it will
* affects the main object (FK needs update).
*/
public boolean modified(Image toCompare)
{
boolean modified = false;
if(!(this == toCompare))
{
if(toCompare instanceof Image.SingleRef)
{
Image.SingleRef other = (Image.SingleRef) toCompare;
Identity current = getIdentity();
Identity otherOid = other.getIdentity();
modified = current != null ? !current.equals(otherOid) : !(otherOid == null);
}
}
return modified;
}
public String toString()
{
return ClassUtils.getShortClassName(this.getClass()) + "[reference=" + getIdentity() + "]";
}
}
//===================================================================
// inner class
//===================================================================
public static class Field extends Image
{
private final FieldType type;
private final Object value;
public Field(FieldType type, Object value)
{
this.type = type;
this.value = value;
}
public void cleanup(boolean reuse)
{
}
void referenceProcessing(Image oldImage)
{
// nothing to do
}
/** If a field value has changed return 'true'. */
public boolean modified(Image other)
{
boolean result = false;
if(this == other)
{
result = true;
}
else
{
if(other instanceof Field)
{
result = !type.equals(value, ((Field) other).value);
}
}
return result;
}
public String toString()
{
return ClassUtils.getShortClassName(this.getClass()) + "[type=" + type + ", value=" + value + "]";
}
}
//===================================================================
// inner interface
//===================================================================
public static interface ImageListener
{
public void addedOneToOne(ObjectReferenceDescriptor ord, Object refObjOrProxy, Identity oid);
public void deletedOneToOne(ObjectReferenceDescriptor ord, Object refObjOrProxy, Identity oid, boolean needsUnlink);
public void addedXToN(CollectionDescriptor ord, Object refObjOrProxy, Identity oid);
public void deletedXToN(CollectionDescriptor ord, Object refObjOrProxy, Identity oid);
public PersistenceBrokerInternal getBroker();
}
//====================================================
// inner class
//====================================================
/**
* Thrown if something unexpected is happen when handling the
* object images for state detection.
*/
public static class ImageException extends OJBRuntimeException
{
public ImageException()
{
}
public ImageException(String msg)
{
super(msg);
}
public ImageException(Throwable cause)
{
super(cause);
}
public ImageException(String msg, Throwable cause)
{
super(msg, cause);
}
}
}