EntityCmp2Desc.java

package org.objectweb.jonas_ejb.deployment.api;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.objectweb.jonas_ejb.deployment.xml.AssemblyDescriptor;
import org.objectweb.jonas_ejb.deployment.xml.Entity;
import org.objectweb.jonas_ejb.deployment.xml.JonasEntity;
import org.objectweb.jonas_ejb.deployment.xml.Query;
import org.objectweb.jonas_ejb.deployment.ejbql.ParseException;
import org.objectweb.jonas_ejb.lib.BeanNaming;
import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.deployment.xml.JLinkedList;
import org.objectweb.jorm.metainfo.api.MetaObject;


public abstract class EntityCmp2Desc extends EntityCmpDesc {

    private ArrayList ejbRelationshipRoleDesc = new ArrayList();
    private ArrayList jormMOList = new ArrayList();
    protected String abstractSchemaName;

    private static final String JORM_PACKAGE = "jorm";

    private String jormClassName = null;
    private String jormFQClassName = null;
    private String jormAccessorClassName = null;
    private String jormPKClassName = null;
    private String jormPNameGetterClassName = null;
    private String jormBinderClassName = null;


    protected String factoryClassName = null;
    protected DeploymentDescEjb2 dc2d = null;

    public EntityCmp2Desc(ClassLoader classLoader,
                          Entity ent,
                          AssemblyDescriptor asd,
                          JonasEntity jEnt,
                          DeploymentDescEjb2 dc2d,
                          JLinkedList jMDRList,
                                      String fileName)
        throws DeploymentDescException {

        super(classLoader, ent, asd, jEnt, jMDRList, fileName);
        this.dc2d = dc2d;

        // An abstract schema name is required
        if ((ent.getAbstractSchemaName() == null)
            || (ent.getAbstractSchemaName().length() == 0)) {
            throw new DeploymentDescException("abstract-schema-name must be provided for bean " + this.ejbName);
        }
        abstractSchemaName = ent.getAbstractSchemaName();

        // check if persistent fields exist
        if (fieldDesc.isEmpty()) {
            throw new DeploymentDescException("No cmp-field defined in bean " + this.ejbName);
        }
        // check if persistent fields map to getter and setter
        for (Iterator i = fieldDesc.keySet().iterator(); i.hasNext();) {
            String fn = (String) i.next();

            // field should not be defined
            try {
                Field f = ejbClass.getField(fn);
                throw new DeploymentDescException("In cmp-version 2.x, field-name " + fn + " should not be defined in bean " + this.ejbName);
            } catch (NoSuchFieldException e) {
                // this is what we expect: nothing to do
            } catch (SecurityException e) {
                throw new DeploymentDescException("Cannot use java reflexion on " + this.ejbClass.getName());
            }

            try {
                Method getter = null;
                try {
                    getter = ejbClass.getMethod(FieldDesc.getGetterName(fn), (Class[]) null);
                    ((FieldDesc) (fieldDesc.get(fn))).setFieldType(getter.getReturnType());
                } catch (NoSuchMethodException e) {
                    throw new DeploymentDescException("Getter method not found for field-name " + fn + " in bean " + this.ejbName, e);
                }
                try {
                    ejbClass.getMethod(FieldDesc.getSetterName(fn), new Class[]{getter.getReturnType()});
                } catch (NoSuchMethodException e) {
                    throw new DeploymentDescException("Setter method not found for field-name " + fn + " in bean " + this.ejbName, e);
                }
            } catch (SecurityException e) {
                throw new DeploymentDescException("Cannot use java reflexion on " + this.ejbClass.getName());
            }
        }
        
        // isModifiedMethod deprecated for CMP 2.x
        if (jEnt.getIsModifiedMethodName() != null) {
            throw new DeploymentDescException("use of is-modified-method-name deprecated for CMP 2.x");
        }  

        // EJB-QL query
        if (ent.getQueryList() != null) {
            for (Iterator i = ent.getQueryList().iterator(); i.hasNext();) {
                Query q = (Query) i.next();
                boolean foundMatch = false;
                for (Iterator j = getMethodDescIterator(); j.hasNext();) {
                    MethodDesc methd = (MethodDesc) j.next();
                    String methName = q.getQueryMethod().getMethodName();
                    if (methd.matchPattern(null, methName, q.getQueryMethod().getMethodParams())
                        != MethodDesc.APPLY_TO_NOTHING) {
                        foundMatch = true;
                        String query = q.getEjbQl();
                        if (!(methd instanceof MethodCmp2Desc)) {
                            throw new DeploymentDescException("ejbql query " + query + " can't apply to method "
                                                              + methName + " in bean " + ejbName);
                        }
                        try {
                            ((MethodCmp2Desc) methd).setQuery(query);
                        } catch (ParseException e) {
                            throw new DeploymentDescException("Invalid ejbql syntax for bean " + ejbName + ":\n"
                                                              + e.getMessage(query));
                        }
                        if (q.getResultTypeMapping() != null) {
                            ((MethodCmp2Desc) methd).setResultTypeMapping(q.getResultTypeMapping());
                        }
                    }
                }
                if (!foundMatch) {
                    throw new DeploymentDescException("invalid query-method definition for bean " + ejbName + "\nno such method as "
                                                      + MethodCmp2Desc.queryMethodElementToString(q.getQueryMethod()) + "\ncheck method name and method parameters");
                }
            }
        }
        // check that all finder/selecter methods but findByPrimaryKey have a non null query
        for (Iterator j = getMethodDescIterator(); j.hasNext();) {
            MethodDesc md = (MethodDesc) j.next();
            if ((md.isFinder() || md.isEjbSelect()) && !md.isFindByPrimaryKey()) {
                if (((MethodCmp2Desc) md).getQuery() == null) {
                    throw new DeploymentDescException("query not defined for method " + MethodDesc.toString(md.getMethod())
                                                      + " of bean" + ejbName);

                }
            }
        }
        if (isUndefinedPK()) {
           FieldDesc fd = this.newFieldDescInstance();
           fd.setName("JONASAUTOPKFIELD");
           fd.setPrimaryKey(true);
           fieldDesc.put("JONASAUTOPKFIELD", fd);
           ((FieldDesc) (fieldDesc.get("JONASAUTOPKFIELD"))).setFieldType(java.lang.Integer.class); 
           ((FieldJdbcDesc) (fieldDesc.get("JONASAUTOPKFIELD"))).setJdbcFieldName(this.getJdbcAutomaticPkFieldName());
        } 
    }

    public DeploymentDescEjb2 getDeploymentDescEjb2() {
        return dc2d;
    }

    public String getAbstractSchemaName() {
        return abstractSchemaName;
    }

    private String getJormCName() {
        if (jormClassName == null) {
            jormClassName = BeanNaming.firstToUpperCase(abstractSchemaName);
        }
        return jormClassName;
    }

    public String getJormClassName() {
        if (jormFQClassName == null) {
            jormFQClassName = BeanNaming.getClassName(JORM_PACKAGE, getJormCName());
        }
        return jormFQClassName;
    }

    public Collection getJormList() {
        return jormMOList;
    }

    public void addToJormList(MetaObject jobject) {
        jormMOList.add(jobject);
    }

    public void addEjbRelationshipRoleDesc(EjbRelationshipRoleDesc ersrd) {
        ejbRelationshipRoleDesc.add(ersrd);
    }

    public Iterator getEjbRelationshipRoleDescIterator() {
        return ejbRelationshipRoleDesc.iterator();
    }

    public EjbRelationshipRoleDesc getEjbRelationshipRoleDesc(String cmr) {
        for (Iterator i = ejbRelationshipRoleDesc.iterator(); i.hasNext();) {
            EjbRelationshipRoleDesc rsr = (EjbRelationshipRoleDesc) i.next();
            if (rsr.hasCmrField() && cmr.equals(rsr.getCmrFieldName())) {
                return rsr;
            }
        }
        return null;
    }

    protected MethodDesc newMethodDescInstance(Method meth, int index) {
        return new MethodCmp2Desc(this, meth, index);
    }

    public String getJormAccessorClassName() {
        if (jormAccessorClassName == null) {
            jormAccessorClassName = BeanNaming.getClassName(JORM_PACKAGE, getJormCName() + "Accessor");
        }
        return jormAccessorClassName;
    }

    public String getJormBindingClassName() {
        return BeanNaming.getClassName(JORM_PACKAGE, "rdb." + getJormCName() + "Binding");
    }

    public String getFactoryClassName() {
        return BeanNaming.getClassName(JORM_PACKAGE, "rdb." + getJormCName() + "Mapping");
    }

    public String getJormPKClassName() {
        if (! hasPrimaryKeyField() && jormPKClassName == null) {
            jormPKClassName = BeanNaming.getClassName(JORM_PACKAGE, 
                                                      BeanNaming.getBaseName(getPrimaryKeyClass().getName()));
        }
        return jormPKClassName;
    }

    public String getJormPNameGetterClassName() {
        if (! hasPrimaryKeyField() && jormPNameGetterClassName == null) {
            jormPNameGetterClassName = getJormPKClassName() + "PNG";
        }
        return jormPNameGetterClassName;
    }

    public String getJormBinderClassName() {
        if (jormBinderClassName == null) {
            if (hasPrimaryKeyField()) {
                jormBinderClassName = "org.objectweb.jorm.facility.naming.basidir.BasidBinder";
            } else {
                jormBinderClassName = getJormPKClassName() + "Binder";
            }
        }
        return jormBinderClassName;
    }

    public boolean needJormCoherenceHelper() {
        return ejbRelationshipRoleDesc.iterator().hasNext();
    }

    public String getJormCoherenceHelperItfName() {
        return "JOnAS" + ejbName + "CoherenceHelper";
    }

    public String getJormCoherenceHelperPackageName() {
        return BeanNaming.getPackageName(getFullDerivedBeanName());
    }

    public String getJormCoherenceHelperFQItfName() {
        String pn = getJormCoherenceHelperPackageName();
        return (pn != null && pn.length() > 0
                ? pn + "." + getJormCoherenceHelperItfName()
                : getJormCoherenceHelperItfName());
    }

    public String toString() {
        StringBuffer ret = new StringBuffer();
        ret.append(super.toString());
        for (Iterator i = ejbRelationshipRoleDesc.iterator(); i.hasNext(); ) {
            ret.append("\nejbRelationshipRoleDesc[]=" + i.next());
        }
        ret.append("\ngetAbstractSchemaName()=" + getAbstractSchemaName());
        ret.append("\ngetJormAccessorClassName() = " + getJormAccessorClassName());
        ret.append("\nneedJormCoherenceHelper() = " + needJormCoherenceHelper());
        return ret.toString();
    }

}

---