| /* |
| * 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.axis2.rmi.metadata.impl; |
| |
| import org.apache.axis2.rmi.Configurator; |
| import org.apache.axis2.rmi.config.ClassInfo; |
| import org.apache.axis2.rmi.config.FieldInfo; |
| import org.apache.axis2.rmi.exception.MetaDataPopulateException; |
| import org.apache.axis2.rmi.exception.SchemaGenerationException; |
| import org.apache.axis2.rmi.metadata.AttributeField; |
| import org.apache.axis2.rmi.metadata.ElementField; |
| import org.apache.axis2.rmi.metadata.Field; |
| import org.apache.axis2.rmi.metadata.Type; |
| import org.apache.axis2.rmi.metadata.xml.XmlImport; |
| import org.apache.axis2.rmi.metadata.xml.XmlSchema; |
| import org.apache.axis2.rmi.metadata.xml.XmlType; |
| import org.apache.axis2.rmi.metadata.xml.impl.XmlTypeImpl; |
| import org.apache.axis2.rmi.util.Constants; |
| import org.apache.axis2.rmi.util.JavaTypeToQNameMap; |
| |
| import javax.xml.namespace.QName; |
| import java.beans.BeanInfo; |
| import java.beans.IntrospectionException; |
| import java.beans.Introspector; |
| import java.beans.PropertyDescriptor; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| |
| public class TypeImpl implements Type { |
| /** |
| * java class corresponds to this XmlType object |
| */ |
| private Class javaClass; |
| |
| /** |
| * list of element Field objects for this java class |
| */ |
| private List elementFields; |
| |
| /** |
| * list of attribute Field objects for this java class |
| */ |
| private List attributeFields; |
| |
| /** |
| * name of the Type : class name |
| */ |
| private String name; |
| |
| /** |
| * namespace of the type : depends on the package |
| */ |
| private String namespace; |
| |
| /** |
| * parent type for this type |
| */ |
| private Type parentType; |
| |
| /** |
| * xml metadata type correponding to this type object |
| */ |
| private XmlType xmlType; |
| |
| private boolean isSchemaGenerated; |
| |
| |
| public TypeImpl() { |
| this.elementFields = new ArrayList(); |
| this.attributeFields = new ArrayList(); |
| } |
| |
| public TypeImpl(Class javaClass) { |
| this(); |
| this.javaClass = javaClass; |
| } |
| |
| /** |
| * popualate the meta data corresponding to this type |
| * @param configurator |
| */ |
| public void populateMetaData(Configurator configurator, |
| Map processedTypeMap) |
| throws MetaDataPopulateException { |
| // java class should alrady have populated. |
| |
| // if javaTypeToQNameMap contains this key then this is an either |
| // primitive type or a Simple known type. we don't have to populate |
| // the attribues |
| try { |
| if (!JavaTypeToQNameMap.containsKey(this.javaClass)) { |
| this.name = this.javaClass.getName(); |
| this.name = this.name.substring(this.name.lastIndexOf(".") + 1); |
| this.namespace = configurator.getNamespace(this.javaClass.getPackage().getName()); |
| |
| Class superClass = this.javaClass.getSuperclass(); |
| |
| // if the supper class is Object class nothing to warry |
| if (!superClass.equals(Object.class) && !superClass.equals(Exception.class)) { |
| // then this is an extension class and we have to processit |
| if (!processedTypeMap.containsKey(superClass)) { |
| Type superClassType = new TypeImpl(superClass); |
| processedTypeMap.put(superClass, superClassType); |
| superClassType.populateMetaData(configurator, processedTypeMap); |
| } |
| this.setParentType((Type) processedTypeMap.get(superClass)); |
| } |
| |
| // we need informatin only about this class |
| // supper class information is processed in the super class type |
| ClassInfo customClassInfo = configurator.getClassInfo(this.javaClass); |
| BeanInfo beanInfo = Introspector.getBeanInfo(this.javaClass, this.javaClass.getSuperclass()); |
| PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); |
| Field field; |
| for (int i = 0; i < propertyDescriptors.length; i++) { |
| // remove the class descriptor |
| if ((customClassInfo != null) && |
| (customClassInfo.getFieldInfo(propertyDescriptors[i].getName()) != null)) { |
| FieldInfo fieldInfo = customClassInfo.getFieldInfo(propertyDescriptors[i].getName()); |
| if (fieldInfo.isElement()) { |
| field = new ElementField(propertyDescriptors[i], this.namespace); |
| field.populateMetaData(configurator, processedTypeMap); |
| this.elementFields.add(field); |
| } else { |
| // we use the attribute name space as null |
| field = new AttributeField(propertyDescriptors[i], null); |
| field.populateMetaData(configurator, processedTypeMap); |
| this.attributeFields.add(field); |
| } |
| if (fieldInfo.getXmlName() != null) { |
| field.setName(fieldInfo.getXmlName()); |
| } |
| } else { |
| field = new ElementField(propertyDescriptors[i], this.namespace); |
| field.populateMetaData(configurator, processedTypeMap); |
| this.elementFields.add(field); |
| } |
| } |
| } |
| } catch (IntrospectionException e) { |
| throw new MetaDataPopulateException( |
| "Error Occured while getting the Bean info of the class " + this.javaClass.getName(), e); |
| } |
| |
| } |
| |
| /** |
| * this method sets the xmlType correctly. this method should only be invoked |
| * if it has not already processed |
| * @param configurator |
| * @param schemaMap |
| */ |
| |
| public void generateSchema(Configurator configurator, |
| Map schemaMap) |
| throws SchemaGenerationException { |
| |
| // here we have to populate the xmlType object properly |
| this.isSchemaGenerated = true; |
| if (JavaTypeToQNameMap.containsKey(this.javaClass)){ |
| // i.e. this is a basic type |
| // no need to process or add this to schema list |
| this.xmlType = new XmlTypeImpl(JavaTypeToQNameMap.getTypeQName(this.javaClass)); |
| this.xmlType.setSimpleType(true); |
| } else { |
| |
| // get the schema to add the complex type |
| if (schemaMap.get(this.namespace) == null){ |
| // create a new namespace for this schema |
| schemaMap.put(this.namespace, new XmlSchema(this.namespace)); |
| } |
| XmlSchema xmlSchema = (XmlSchema) schemaMap.get(this.namespace); |
| |
| // we have to generate a complex type for this |
| this.xmlType = new XmlTypeImpl(new QName(this.namespace,this.name)); |
| this.xmlType.setSimpleType(false); |
| |
| // set the parent type for this type |
| if (this.parentType != null){ |
| Type parentType = this.parentType; |
| if (!parentType.isSchemaGenerated()){ |
| parentType.generateSchema(configurator,schemaMap); |
| } |
| this.xmlType.setParentType(parentType.getXmlType()); |
| // import the complex type namespace if needed. |
| if (!xmlSchema.containsNamespace(this.xmlType.getParentType().getQname().getNamespaceURI())){ |
| // if the element namespace does not exists we have to add it |
| if (!this.xmlType.getParentType().getQname().getNamespaceURI().equals(Constants.URI_2001_SCHEMA_XSD)) { |
| XmlImport xmlImport = new XmlImport(this.xmlType.getParentType().getQname().getNamespaceURI()); |
| xmlSchema.addImport(xmlImport); |
| } |
| xmlSchema.addNamespace(this.xmlType.getParentType().getQname().getNamespaceURI()); |
| } |
| |
| } |
| |
| // add elements of the elementFields |
| ElementField elementField; |
| for (Iterator iter = this.elementFields.iterator();iter.hasNext();){ |
| elementField = (ElementField) iter.next(); |
| if (!elementField.isSchemaGenerated()){ |
| // if it is not already processed process it. |
| elementField.generateSchema(configurator,schemaMap); |
| } |
| this.xmlType.addElement(elementField.getElement()); |
| // we have to set the namespaces of these element complex types properly |
| QName elementTypeQName = elementField.getElement().getType().getQname(); |
| if (!xmlSchema.containsNamespace(elementTypeQName.getNamespaceURI())){ |
| // if the element namespace does not exists we have to add it |
| if (!elementTypeQName.getNamespaceURI().equals(Constants.URI_2001_SCHEMA_XSD)) { |
| XmlImport xmlImport = new XmlImport(elementTypeQName.getNamespaceURI()); |
| xmlSchema.addImport(xmlImport); |
| } |
| xmlSchema.addNamespace(elementTypeQName.getNamespaceURI()); |
| } |
| |
| } |
| |
| //add attribute fields |
| AttributeField attributeField; |
| for (Iterator iter = this.attributeFields.iterator(); iter.hasNext();){ |
| attributeField = (AttributeField) iter.next(); |
| if (!attributeField.isSchemaGenerated()){ |
| // if it is not already processed process it. |
| attributeField.generateSchema(configurator,schemaMap); |
| } |
| this.xmlType.addAttribute(attributeField.getAttribute()); |
| // we have to set the namespaces of these element complex types properly |
| QName attributeTypeQName = attributeField.getAttribute().getType().getQname(); |
| if (!xmlSchema.containsNamespace(attributeTypeQName.getNamespaceURI())){ |
| // if the element namespace does not exists we have to add it |
| if (!attributeTypeQName.getNamespaceURI().equals(Constants.URI_2001_SCHEMA_XSD)) { |
| XmlImport xmlImport = new XmlImport(attributeTypeQName.getNamespaceURI()); |
| xmlSchema.addImport(xmlImport); |
| } |
| xmlSchema.addNamespace(attributeTypeQName.getNamespaceURI()); |
| } |
| |
| } |
| // finally add this complex type to schema map |
| xmlSchema.addComplexType(this.xmlType); |
| |
| } |
| |
| } |
| |
| public void populateAllElementFields(List elementFieldsList){ |
| // we have to first add the parent details to keep the order. |
| if (this.parentType != null){ |
| this.parentType.populateAllElementFields(elementFieldsList); |
| } |
| elementFieldsList.addAll(this.elementFields); |
| } |
| |
| public void populateAllAttributeFields(List attributeFieldsList) { |
| // we have to first add the parent details to keep the order. |
| if (this.parentType != null){ |
| this.parentType.populateAllAttributeFields(attributeFieldsList); |
| } |
| attributeFieldsList.addAll(this.attributeFields); |
| } |
| |
| public List getAllElementFields(){ |
| List allElementsList = new ArrayList(); |
| populateAllElementFields(allElementsList); |
| return allElementsList; |
| } |
| |
| public List getAllAttributeFields() { |
| List allAttributesList = new ArrayList(); |
| populateAllAttributeFields(allAttributesList); |
| return allAttributesList; |
| } |
| |
| public boolean isSchemaGenerated() { |
| return isSchemaGenerated; |
| } |
| |
| public void setSchemaGenerated(boolean schemaGenerated) { |
| isSchemaGenerated = schemaGenerated; |
| } |
| |
| public Class getJavaClass() { |
| return javaClass; |
| } |
| |
| public void setJavaClass(Class javaClass) { |
| this.javaClass = javaClass; |
| } |
| |
| public List getElementFields() { |
| return elementFields; |
| } |
| |
| public void setElementFields(List elementFields) { |
| this.elementFields = elementFields; |
| } |
| |
| public String getName() { |
| return name; |
| } |
| |
| public void setName(String name) { |
| this.name = name; |
| } |
| |
| public String getNamespace() { |
| return namespace; |
| } |
| |
| public void setNamespace(String namespace) { |
| this.namespace = namespace; |
| } |
| |
| public XmlType getXmlType() { |
| return xmlType; |
| } |
| |
| public void setXmlType(XmlType xmlType) { |
| this.xmlType = xmlType; |
| } |
| |
| public Type getParentType() { |
| return parentType; |
| } |
| |
| public void setParentType(Type parentType) { |
| this.parentType = parentType; |
| } |
| |
| public List getAttributeFields() { |
| return attributeFields; |
| } |
| |
| public void setAttributeFields(List attributeFields) { |
| this.attributeFields = attributeFields; |
| } |
| } |
