/*******************************************************************************
* Copyright (c) 2001, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
/*
* Created on Oct 24, 2003
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package org.eclipse.jst.j2ee.ejb.internal.util;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.WeakHashMap;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.jem.java.Field;
import org.eclipse.jem.java.JavaClass;
import org.eclipse.jem.java.JavaVisibilityKind;
import org.eclipse.jst.j2ee.ejb.CMPAttribute;
import org.eclipse.jst.j2ee.ejb.ContainerManagedEntity;
import org.eclipse.jst.j2ee.ejb.EjbFactory;
import org.eclipse.jst.j2ee.ejb.EjbPackage;
import org.eclipse.jst.j2ee.ejb.internal.impl.ContainerManagedEntityImpl;
/**
* @author jlanuti
*
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
public class CMPKeySynchronizationAdapter extends AdapterImpl {
public static final String ADAPTER_TYPE = CMPKeySynchronizationAdapter.class.getName();
private boolean initialized = false;
protected ContainerManagedEntity cmp = null;
private boolean isUpdating = false;
private boolean isEnabled = true;
private static WeakHashMap<CMPKeySynchronizationAdapter, Object> unresolvedCMPAttributesToFlush = new WeakHashMap<CMPKeySynchronizationAdapter, Object>();
/**
* Default constructor
*/
public CMPKeySynchronizationAdapter(ContainerManagedEntity cmp) {
super();
this.cmp = cmp;
}
/**
* If the keyAttributes list is empty, try to reflect
* the keyAttributes from the fields of the primaryKey class.
*/
public void initializeKeyAttributes() {
if(cmp == null || initialized)
return;
//Disable notifications while we initialize
cmp.eSetDeliver(false);
try {
Resource res = cmp.eResource();
if(res == null)
return;
boolean cachedIsModified = res.isModified();
try {
// Handle primkeyfield scenario
if (cmp.getPrimKeyField()!=null)
initializeForPrimKey();
// Handle compound key scenario
else
initializeForCompoundKey();
} finally {
res.setModified(cachedIsModified);
}
} finally {
cmp.eSetDeliver(true);
initialized = true;
}
}
protected void initializeForPrimKey() {
// Ensure the key attributes list contains only the primKeyField attribute
if (!(getKeyAttributes().size()==1 && getKeyAttributes().contains(cmp.getPrimKeyField())))
primKeyFieldChanged(cmp.getPrimKeyField());
}
protected void initializeForCompoundKey() {
List keys = getKeyAttributes();
// clear key list
keys.clear();
//ensure the key class is not null
JavaClass keyClass = cmp.getPrimaryKey();
if (keyClass == null)
return;
keyClass.eAdapters().add(this);
// reflect key fields into key attributes list
List keyFields = keyClass.getFieldsExtended();
if(keyFields.size() == 0){
unresolvedCMPAttributesToFlush.put(this, null);
}else{
unresolvedCMPAttributesToFlush.remove(this);
}
for (int i = 0; i < keyFields.size(); i++) {
Field field = (Field) keyFields.get(i);
if (field.getJavaVisibility() == JavaVisibilityKind.PUBLIC_LITERAL) { //only public fields
CMPAttribute keyAttribute = cmp.getPersistentAttribute(field.getName());
if (keyAttribute != null)
keys.add(keyAttribute);
}
}
}
public static void flushUnresolvedKeyAttributesOnCleanBuild(){
Iterator itr = unresolvedCMPAttributesToFlush.keySet().iterator();
while(itr.hasNext()){
CMPKeySynchronizationAdapter curAdapter = (CMPKeySynchronizationAdapter)itr.next();
curAdapter.initialized = false;
curAdapter.initializeKeyAttributes();
}
}
@Override
public void notifyChanged(Notification notification) {
if (isUpdating || !isEnabled) return; //we don't want to react to our own changes
try {
isUpdating = true;
EClass featureClass = ((EObject)notification.getNotifier()).eClass();
if (EjbPackage.eINSTANCE.getContainerManagedEntity().equals(featureClass)) {
switch (notification.getFeatureID(ContainerManagedEntity.class)) {
// handle if cmp attribute is updated, added, removed
case EjbPackage.CONTAINER_MANAGED_ENTITY__PERSISTENT_ATTRIBUTES : {
handleCMPAttributeEvent(notification);
break;
}
// handle the key attributes list is updated programatically
case EjbPackage.CONTAINER_MANAGED_ENTITY__KEY_ATTRIBUTES : {
handleCMPAttributeEvent(notification);
break;
}
// handle if the key class is changed,added, removed
case EjbPackage.CONTAINER_MANAGED_ENTITY__PRIMARY_KEY : {
handleKeyClassEvent(notification);
break;
}
// handle prim key field sets, adds, removes
case EjbPackage.CONTAINER_MANAGED_ENTITY__PRIM_KEY_FIELD : {
handlePrimKeyFieldEvent(notification);
break;
}
}
} else if (EjbPackage.eINSTANCE.getCMPAttribute().equals(featureClass)) {
switch (notification.getFeatureID(CMPAttribute.class)) {
// handle a set or change of an attribute name
case (EjbPackage.CMP_ATTRIBUTE__NAME) : {
handleCMPAttributeRenameEvent((CMPAttribute)notification.getNotifier(), notification.getOldValue());
break;
}
}
}
} finally {
// restore initial notification state
isUpdating = false;
}
}
/**
* @param attribute
*/
private void handleCMPAttributeRenameEvent(CMPAttribute attribute, Object oldValue) {
// if renamed attribute was in key and is not anymore, remove it from key list
if (getKeyAttributes().contains(attribute)) {
if (!isAttributeKeyClassField(attribute.getName()))
removeKeyAttribute(attribute,(String)oldValue);
}
// if renamed attribute is now part of the key, add it to the key list
else
attributeAdded(attribute);
}
/**
* @param notification
*/
private void handlePrimKeyFieldEvent(Notification notification) {
EObject newPrimKeyField = (EObject)notification.getNewValue();
cmp.setPrimKeyField((CMPAttribute)newPrimKeyField);
// if primKeyField is removed or a proxy, recompute key attributes based on key class
if (newPrimKeyField == null || newPrimKeyField.eIsProxy()) {
CMPAttribute primField = (CMPAttribute)newPrimKeyField;
if (primField!=null && primField.getName() == null) {
primField.setName(((InternalEObject)primField).eProxyURI().toString());
makePrimKeyFieldProxy(primField.getName());
}
removeAllKeyAttributes();
initialized = false;
initializeKeyAttributes();
}
// Ensure the key attributes list contains only the primKeyField attribute
else if (!(getKeyAttributes().size()==1 && getKeyAttributes().contains(newPrimKeyField))) {
primKeyFieldChanged(newPrimKeyField);
}
}
/**
* @param notification
*/
private void handleKeyClassEvent(Notification notification) {
// if primkey null or proxy, clear key fields and reinitialize if key class not null
if (cmp.getPrimKeyField()==null || cmp.getPrimKeyField().eIsProxy()) {
keyClassChanged();
}
// if primkey is not null, then do nothing
}
/**
* @param notification
*/
private void handleCMPAttributeEvent(Notification notification) {
int eventType = notification.getEventType();
// handle a CMPAttribute added
if (eventType == Notification.ADD) {
attributeAdded((CMPAttribute)notification.getNewValue());
}
// handle a CMPAttribute removed
else if (eventType == Notification.REMOVE) {
CMPAttribute attribute = (CMPAttribute)notification.getOldValue();
// remove this adapter from the deleted attribute
attribute.eAdapters().remove(this);
removeKeyAttribute(attribute, attribute.getName());
}
}
protected void removeKeyAttribute(CMPAttribute attribute, String oldName) {
// if attribute was a key attribute it will be removed, otherwise do nothing
getKeyAttributes().remove(attribute);
// if it is the prim key attribute, then make the prim key attribute a proxy
if (cmp.getPrimKeyField()!=null && cmp.getPrimKeyField().equals(attribute)) {
makePrimKeyFieldProxy(oldName);
}
}
public void makePrimKeyFieldProxy(String oldName) {
if (cmp.getPrimKeyField() == null) return;
cmp.setPrimKeyField(EjbFactory.eINSTANCE.createCMPAttribute());
cmp.getPrimKeyField().setName(oldName);
((InternalEObject)cmp.getPrimKeyField()).eSetProxyURI(URI.createURI(oldName));
}
protected void removeAllKeyAttributes() {
// clear key attributes list on cmp
getKeyAttributes().clear();
}
protected void addKeyAttribute(CMPAttribute attribute) {
CMPAttribute primKeyField = cmp.getPrimKeyField();
// if prim key is null add attribute to key list
if (primKeyField==null || primKeyField.eIsProxy()) {
if (!getKeyAttributes().contains(attribute))
getKeyAttributes().add(attribute);
// if att is only key att, and type is the key class type, set the prim key field
if (getKeyAttributes().size()==1 && attribute.getType().equals(cmp.getPrimaryKey()))
cmp.setPrimKeyField(attribute);
}
// if primkey set + primkeyfield is the new attribute ensure its the only one
else if (primKeyField.equals(attribute)) {
if (!(getKeyAttributes().size()==1 && getKeyAttributes().contains(attribute))) {
getKeyAttributes().clear();
getKeyAttributes().add(attribute);
}
}
// if primkey set,new attribute not prim key, key atts > 1, remove primkey field
else {
cmp.setPrimKeyField(null);
if (!getKeyAttributes().contains(attribute))
getKeyAttributes().add(attribute);
}
}
protected void attributeAdded(CMPAttribute attribute) {
//Make sure cmp key adapters are initialized if needed
cmp.getKeyAttributes();
// add this as a listener to name changes on this attribute
if (!attribute.eAdapters().contains(this))
attribute.eAdapters().add(this);
if (attribute.getName() ==null) return;
// add it to the key list if applicable and sort the key list
if (isAttributeKeyClassField(attribute.getName())) {
addKeyAttribute(attribute);
sortKeyAttributeList();
}
// if new attribute name is now prim key name, fix up prim key field
else if (cmp.getPrimKeyField()!=null && cmp.getPrimKeyField().eIsProxy() && attribute.getName().equals(cmp.getPrimKeyField().getName())) {
cmp.setPrimKeyField(attribute);
primKeyFieldChanged(attribute);
}
}
/**
* Is the cmp attribute also a field in the key class?
*/
protected boolean isAttributeKeyClassField(String attributeName) {
// ensure key class is not null
JavaClass keyClass = cmp.getPrimaryKey();
if (keyClass == null)
return false;
// see if the attribute name matchs any of the reflected key class public field names
List keyFields = keyClass.getFieldsExtended();
for (int i = 0; i < keyFields.size(); i++) {
Field field = (Field) keyFields.get(i);
if (field.getJavaVisibility() == JavaVisibilityKind.PUBLIC_LITERAL) {
if (field.getName().equals(attributeName))
return true;
}
}
return false;
}
/**
* Sort the list of the key attributes to match the order of the key class
*/
private void sortKeyAttributeList() {
List result = new ArrayList();
JavaClass keyClass = cmp.getPrimaryKey();
if (keyClass == null) return;
List keyFields = keyClass.getFieldsExtended();
List currentKeys = getKeyAttributes();
// create a new list of the attributes in order of key class fields.
for (int i = 0; i < keyFields.size(); i++) {
Field field = (Field) keyFields.get(i);
if (field.getJavaVisibility() == JavaVisibilityKind.PUBLIC_LITERAL) { //only public fields
for (int j=0; j<currentKeys.size(); j++) {
CMPAttribute attribute = (CMPAttribute) currentKeys.get(j);
if (field.getName().equals(attribute.getName()))
result.add(attribute);
}
}
}
//clear list and set the new key attribute order on the cmp
getKeyAttributes().clear();
getKeyAttributes().addAll(result);
}
protected void keyClassChanged() {
JavaClass key = cmp.getPrimaryKey();
if (key !=null)
key.eAdapters().remove(this);
// if not prim key class, clear key attribute list
removeAllKeyAttributes();
initialized = false;
initializeKeyAttributes();
}
protected void primKeyFieldChanged(EObject primKeyField) {
// if a primKeyField is added, do a remove all and an add
removeAllKeyAttributes();
if (primKeyField != null && !primKeyField.eIsProxy()) {
if (!primKeyField.eAdapters().contains(this))
primKeyField.eAdapters().add(this);
getKeyAttributes().add(primKeyField);
}
}
private EList getKeyAttributes() {
return ((ContainerManagedEntityImpl)cmp).getKeyAttributesGen();
}
/* (non-Javadoc)
* @see org.eclipse.emf.common.notify.impl.AdapterImpl#setTarget(org.eclipse.emf.common.notify.Notifier)
*/
@Override
public void setTarget(Notifier newTarget) {
super.setTarget(newTarget);
}
/* (non-Javadoc)
* @see org.eclipse.emf.common.notify.impl.AdapterImpl#isAdapterForType(java.lang.Object)
*/
@Override
public boolean isAdapterForType(Object type) {
return ADAPTER_TYPE.equals(type);
}
//To turn sync on or off
public void setEnabled(boolean enabled){
isEnabled = enabled;
}
}