public JawsApplicationMetaData(ApplicationMetaData amd,
    ClassLoader cl) throws DeploymentException 
{
   // Static --------------------------------------------------------
   // Constructors --------------------------------------------------
      // initialisation of this object goes as follows:
      //  - constructor
      //  - importXml() for standardjaws.xml and jaws.xml
      //  - create()
      // the classloader is the same for all the beans in the application
      classLoader = cl;
      applicationMetaData = amd;
      // create metadata for all jaws-managed cmp entities
      // we do that here in case there is no jaws.xml
      Iterator beans = applicationMetaData.getEnterpriseBeans();
      while (beans.hasNext())
      {
         BeanMetaData bean = (BeanMetaData)beans.next();
         // only take entities
         if (bean.isEntity())
         {
            EntityMetaData entity = (EntityMetaData)bean;
            // only take jaws-managed CMP entities
            if (entity.isCMP() &&
                entity.getContainerConfiguration().getPersistenceManager().equals(JPM))
            {
               JawsEntityMetaData jawsEntity = new JawsEntityMetaData(this, entity);
               entities.put(entity.getEjbName(), jawsEntity);
            }
         }
      }
}

 public  void create() throws DeploymentException 
{
      // find the datasource
      if (! dbURL.startsWith("jdbc:")) {
         try {
            dataSource = (DataSource)new InitialContext().lookup(dbURL);
         } catch (NamingException e) {
            throw new DeploymentException(e.getMessage());
         }
      }
}

 public JawsEntityMetaData getBeanByEjbName(String name) 
{
      return (JawsEntityMetaData)entities.get(name);
}

 protected ClassLoader getClassLoader() 
{
 return classLoader;
}

 public DataSource getDataSource() 
{
 return dataSource;
}

 public String getDbURL() 
{
 return dbURL;
}

 public TypeMappingMetaData getTypeMapping() 
{
 return typeMapping;
}

 public  void importXml(Element element) throws DeploymentException 
{
      // importXml will be called at least once: with standardjaws.xml
      // it may be called a second time with user-provided jaws.xml
      // we must ensure to set all defaults values in the first call
      Iterator iterator;
      // first get the type mappings. (optional, but always set in standardjaws.xml)
      Element typeMaps = getOptionalChild(element, "type-mappings");
      if (typeMaps != null)
      {
         iterator = getChildrenByTagName(typeMaps, "type-mapping-definition");
         while (iterator.hasNext())
         {
            Element typeMappingElement = (Element)iterator.next();
            TypeMappingMetaData typeMapping = new TypeMappingMetaData();
            try
            {
               typeMapping.importXml(typeMappingElement);
            }
            catch (DeploymentException e)
            {
               throw new DeploymentException(
                  "Error in jaws.xml for type-mapping-definition " +
                  typeMapping.getName() + ": " + e.getMessage()
               );
            }
            typeMappings.put(typeMapping.getName(), typeMapping);
         }
      }
      // get the datasource (optional, but always set in standardjaws.xml)
      Element db = getOptionalChild(element, "datasource");
      if (db != null) dbURL = getElementContent(db);
      // Make sure it is prefixed with java:
      if (!dbURL.startsWith("java:/"))
         dbURL = "java:/"+dbURL;
      // get the type mapping for this datasource
      // (optional, but always set in standardjaws.xml)
      String typeMappingString =
         getElementContent(getOptionalChild(element, "type-mapping"));
      if (typeMappingString != null)
      {
         typeMapping = (TypeMappingMetaData)typeMappings.get(typeMappingString);
         if (typeMapping == null)
         {
            throw new DeploymentException(
               "Error in jaws.xml : type-mapping " + typeMappingString + " not found");
         }
      }
      // get default settings for the beans (optional, but always set in standardjaws.xml)
      Element defaultEntity = getOptionalChild(element, "default-entity");
      if (defaultEntity != null)
      {
         iterator = entities.values().iterator();
         while (iterator.hasNext())
         {
            ((JawsEntityMetaData)iterator.next()).importXml(defaultEntity);
         }
      }
      // get the beans data (only in jaws.xml)
      Element enterpriseBeans = getOptionalChild(element, "enterprise-beans");
      if (enterpriseBeans != null)
      {
         String ejbName = null;
         try
         {
            iterator = getChildrenByTagName(enterpriseBeans, "entity");
            while (iterator.hasNext())
            {
               Element bean = (Element) iterator.next();
               ejbName = getElementContent(getUniqueChild(bean, "ejb-name"));
               JawsEntityMetaData entity = (JawsEntityMetaData)entities.get(ejbName);
               if (entity != null)
               {
                  entity.importXml(bean);
               }
               else
               {
                  log.warn(
                     "Warning: data found in jaws.xml for entity " + ejbName +
                     " but bean is not a jaws-managed cmp entity in ejb-jar.xml"
                  );
               }
            }
         }
         catch (DeploymentException e)
         {
            throw new DeploymentException(
               "Error in jaws.xml for Entity " + ejbName + ": " + e.getMessage());
         }
      }
}