axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r415947 - /webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/writer/CStructWriter.java
Date Wed, 21 Jun 2006 09:12:01 GMT
Author: samisa
Date: Wed Jun 21 02:12:00 2006
New Revision: 415947

URL: http://svn.apache.org/viewvc?rev=415947&view=rev
Log:
Adding the CStructWriter needed for C code generation

Added:
    webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/writer/CStructWriter.java

Added: webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/writer/CStructWriter.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/writer/CStructWriter.java?rev=415947&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/writer/CStructWriter.java
(added)
+++ webservices/axis2/trunk/java/modules/adb-codegen/src/org/apache/axis2/schema/writer/CStructWriter.java
Wed Jun 21 02:12:00 2006
@@ -0,0 +1,682 @@
+package org.apache.axis2.schema.writer;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.apache.axis2.schema.typemap.JavaTypeMap;
+import org.apache.axis2.schema.CompilerOptions;
+import org.apache.axis2.schema.SchemaCompilationException;
+import org.apache.axis2.schema.BeanWriterMetaInfoHolder;
+import org.apache.axis2.schema.SchemaCompiler;
+import org.apache.axis2.schema.util.SchemaPropertyLoader;
+import org.apache.axis2.schema.util.PrimitiveTypeFinder;
+import org.apache.axis2.schema.i18n.SchemaCompilerMessages;
+import org.apache.axis2.util.XSLTUtils;
+import org.apache.axis2.util.URLProcessor;
+import org.apache.axis2.util.JavaUtils;
+import org.apache.axis2.util.XSLTTemplateProcessor;
+import org.apache.ws.commons.schema.XmlSchemaElement;
+import org.apache.ws.commons.schema.XmlSchemaComplexType;
+import org.apache.ws.commons.schema.XmlSchemaSimpleType;
+
+import javax.xml.transform.Templates;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.stream.StreamSource;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.namespace.QName;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.*;
+
+/**
+ * Java Bean writer for the schema compiler.
+ */
+public class CStructWriter implements BeanWriter {
+
+    public static final String WRAPPED_DATABINDING_CLASS_NAME = "WrappedDatabinder";
+    public static final String AXIS2_PREFIX = "axis2_";
+    private String javaBeanTemplateName = null;
+    private boolean templateLoaded = false;
+    private Templates sourceTemplateCache;
+    private Templates headerTemplateCache;
+
+    private List namesList;
+    private static int count = 0;
+    private boolean wrapClasses = false;
+    private boolean writeClasses=false;
+
+    protected File rootDir;
+
+    private Document globalWrappedSourceDocument;
+    private Document globalWrappedHeaderDocument;
+
+    private Map modelMap = new HashMap();
+    private static final String DEFAULT_PACKAGE = "adb";
+
+    private Map baseTypeMap = new JavaTypeMap().getTypeMap();
+
+
+    /**
+     * Default constructor
+     */
+    public CStructWriter() {
+    }
+
+    /**
+     * This returns a map of Qnames vs DOMDocument models. One can use this method to
+     * obtain the raw DOMmodels used to write the classes.
+     * This has no meaning when the classes are supposed to be wrapped  so the
+     *
+     * @see BeanWriter#getModelMap()
+     * @return Returns Map.
+     */
+    public Map getModelMap(){
+        return modelMap;
+    }
+
+    public void init(CompilerOptions options) throws SchemaCompilationException {
+        try {
+            initWithFile(options.getOutputLocation());
+
+            writeClasses = options.isWriteOutput();
+            if (!writeClasses){
+                wrapClasses = false;
+            }else{
+                wrapClasses = options.isWrapClasses();
+            }
+
+            //if the wrap mode is set then create a global document to keep the wrapped
+            //element models
+            if (options.isWrapClasses()) {
+                globalWrappedSourceDocument = XSLTUtils.getDocument();
+                Element rootElement = XSLTUtils.getElement(globalWrappedSourceDocument, "beans");
+                globalWrappedSourceDocument.appendChild(rootElement);
+                XSLTUtils.addAttribute(globalWrappedSourceDocument, "name", CStructWriter.WRAPPED_DATABINDING_CLASS_NAME,
rootElement);
+
+                globalWrappedHeaderDocument = XSLTUtils.getDocument();
+                rootElement = XSLTUtils.getElement(globalWrappedHeaderDocument, "beans");
+                globalWrappedHeaderDocument.appendChild(rootElement);
+                XSLTUtils.addAttribute(globalWrappedHeaderDocument, "name", CStructWriter.WRAPPED_DATABINDING_CLASS_NAME,
rootElement);
+
+            }
+
+
+        } catch (IOException e) {
+            throw new SchemaCompilationException(e);
+        } catch (ParserConfigurationException e) {
+            throw new SchemaCompilationException(e); //todo need to put correct error messages
+        }
+    }
+
+    /**
+     * @param element
+     * @param typeMap
+     * @param metainf
+     * @return Returns String.
+     * @throws org.apache.axis2.schema.SchemaCompilationException
+     */
+    public String write(XmlSchemaElement element, Map typeMap, BeanWriterMetaInfoHolder metainf)
throws SchemaCompilationException {
+
+        try {
+            QName qName = element.getQName();
+
+            return process(qName, metainf, typeMap, true, null);
+        } catch (Exception e) {
+            throw new SchemaCompilationException(e);
+        }
+
+
+    }
+
+    /**
+     * @param complexType
+     * @param typeMap
+     * @param metainf
+     * @param fullyQualifiedClassName the name returned by makeFullyQualifiedClassName()
or null if it wasn't called
+     * @throws org.apache.axis2.schema.SchemaCompilationException
+     *
+     * @see org.apache.axis2.schema.writer.BeanWriter
+     */
+    public String write(XmlSchemaComplexType complexType, Map typeMap, BeanWriterMetaInfoHolder
metainf, String fullyQualifiedClassName)
+            throws SchemaCompilationException {
+
+        try {
+            //determine the package for this type.
+            QName qName = complexType.getQName();
+            return process(qName, metainf, typeMap, false, fullyQualifiedClassName);
+
+        } catch (SchemaCompilationException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new SchemaCompilationException(e);
+        }
+
+
+    }
+
+    /**
+     * @throws SchemaCompilationException
+     * @see org.apache.axis2.schema.writer.BeanWriter#writeBatch()
+     */
+    public void writeBatch() throws SchemaCompilationException {
+        try {
+            if (wrapClasses) {
+
+                File outSource = createOutFile(CStructWriter.WRAPPED_DATABINDING_CLASS_NAME,".c");
+                File outHeader = createOutFile(CStructWriter.WRAPPED_DATABINDING_CLASS_NAME,".h");
+                //parse with the template and create the files
+                parseSource(globalWrappedSourceDocument, outSource);
+                parseHeader(globalWrappedHeaderDocument, outHeader);
+            }
+        } catch (Exception e) {
+            throw new SchemaCompilationException(e);
+        }
+    }
+
+    /**
+     * @param simpleType
+     * @param typeMap
+     * @param metainf
+     * @return Returns String.
+     * @throws org.apache.axis2.schema.SchemaCompilationException
+     * @see org.apache.axis2.schema.writer.BeanWriter#write(org.apache.ws.commons.schema.XmlSchemaSimpleType,
java.util.Map, org.apache.axis2.schema.BeanWriterMetaInfoHolder)
+     */
+    public String write(XmlSchemaSimpleType simpleType, Map typeMap, BeanWriterMetaInfoHolder
metainf) throws SchemaCompilationException {
+        throw new SchemaCompilationException(SchemaCompilerMessages.getMessage("schema.notimplementedxception"));
+    }
+
+    /**
+     * @param rootDir
+     * @throws java.io.IOException
+     * @see org.apache.axis2.schema.writer.BeanWriter
+     */
+    private void initWithFile(File rootDir) throws IOException {
+        if (rootDir == null) {
+            this.rootDir = new File(".");
+        } else if (!rootDir.isDirectory()) {
+            throw new IOException(SchemaCompilerMessages.getMessage("schema.rootnotfolderexception"));
+        } else {
+            this.rootDir = rootDir;
+        }
+
+        namesList = new ArrayList();
+        javaBeanTemplateName = SchemaPropertyLoader.getBeanTemplate();
+    }
+
+
+    /** Make the fully qualified class name for an element or named type
+     * @param qName the qualified Name for this element or type in the schema
+     * @return the appropriate fully qualified class name to use in generated code
+     */
+    public String makeFullyQualifiedClassName(QName qName) {
+
+        String originalName = qName.getLocalPart();
+
+        return makeUniqueCStructName(this.namesList, originalName);
+    }
+
+    /**
+     * A util method that holds common code
+     * for the complete schema that the generated XML complies to
+     * look under other/beanGenerationSchema.xsd
+     *
+     * @param qName
+     * @param metainf
+     * @param typeMap
+     * @param isElement
+     * @param fullyQualifiedClassName the name returned by makeFullyQualifiedClassName()
or null if it wasn't called
+     * @return Returns String.
+     * @throws Exception
+     */
+    private String process(QName qName, BeanWriterMetaInfoHolder metainf, Map typeMap, boolean
isElement, String fullyQualifiedClassName) throws Exception {
+
+        if (fullyQualifiedClassName == null)
+            fullyQualifiedClassName = makeFullyQualifiedClassName(qName);
+        String className = fullyQualifiedClassName;
+
+
+        String originalName = qName.getLocalPart();
+        ArrayList propertyNames = new ArrayList();
+
+        if (!templateLoaded) {
+            loadTemplate();
+        }
+
+        //if wrapped then do not write the classes now but add the models to a global document.
However in order to write the
+        //global class that is generated, one needs to call the writeBatch() method
+        if (wrapClasses) {
+            globalWrappedSourceDocument.getDocumentElement().appendChild(
+                    getBeanElement(globalWrappedSourceDocument, className, originalName,
qName, isElement, metainf, propertyNames, typeMap)
+            );
+            globalWrappedHeaderDocument.getDocumentElement().appendChild(
+                    getBeanElement(globalWrappedHeaderDocument, className, originalName,
qName, isElement, metainf, propertyNames, typeMap)
+            );
+
+        } else {
+            //create the model
+            Document modelSource = XSLTUtils.getDocument();
+            Document modelHeader = XSLTUtils.getDocument();
+            //make the XML
+            modelSource.appendChild(getBeanElement(modelSource, className, originalName,
 qName, isElement, metainf, propertyNames, typeMap));
+            modelHeader.appendChild(getBeanElement(modelHeader, className, originalName,
 qName, isElement, metainf, propertyNames, typeMap));
+
+            if (writeClasses){
+                //create the file
+                File outSource = createOutFile(className, ".c");
+                File outHeader = createOutFile(className, ".h");
+                //parse with the template and create the files
+                parseSource(modelSource, outSource);
+                parseHeader(modelHeader, outHeader);
+            }
+
+            //add the model to the model map
+            modelMap.put(
+                    new QName(qName.getNamespaceURI(),className)
+                    ,modelSource);
+            modelMap.put(
+                    new QName(qName.getNamespaceURI(),className)
+                    ,modelHeader);
+
+
+        }
+
+        //return the fully qualified class name
+        return fullyQualifiedClassName;
+
+    }
+
+
+    /**
+     * @param model
+     * @param className
+     * @param originalName
+     * @param qName
+     * @param isElement
+     * @param metainf
+     * @param propertyNames
+     * @param typeMap
+     * @return Returns Element.
+     * @throws org.apache.axis2.schema.SchemaCompilationException
+     */
+    private Element getBeanElement(
+            Document model, String className, String originalName,
+            QName qName, boolean isElement,
+            BeanWriterMetaInfoHolder metainf, ArrayList propertyNames, Map typeMap
+    ) throws SchemaCompilationException {
+
+        Element rootElt = XSLTUtils.getElement(model, "bean");
+        XSLTUtils.addAttribute(model, "name", className, rootElt);
+        XSLTUtils.addAttribute(model, "originalName", originalName, rootElt);
+        XSLTUtils.addAttribute(model, "nsuri", qName.getNamespaceURI(), rootElt);
+        XSLTUtils.addAttribute(model, "nsprefix", getPrefixForURI(qName.getNamespaceURI(),
qName.getPrefix()), rootElt);
+
+        /* use caps for macros */
+        String capsName = className.toUpperCase();
+        XSLTUtils.addAttribute(model, "caps-name", capsName, rootElt);
+
+
+        if (!wrapClasses) {
+            XSLTUtils.addAttribute(model, "unwrapped", "yes", rootElt);
+        }
+
+        if (!writeClasses){
+            XSLTUtils.addAttribute(model, "skip-write", "yes", rootElt);
+        }
+
+        if (!isElement) {
+            XSLTUtils.addAttribute(model, "type", "yes", rootElt);
+        }
+
+        if (metainf.isAnonymous()) {
+            XSLTUtils.addAttribute(model, "anon", "yes", rootElt);
+        }
+
+        if (metainf.isExtension()) {
+            XSLTUtils.addAttribute(model, "extension", metainf.getExtensionClassName(), rootElt);
+        }
+
+
+        if (metainf.isChoice()) {
+            XSLTUtils.addAttribute(model, "choice", "yes", rootElt);
+        }
+
+        if (metainf.isOrdered()) {
+            XSLTUtils.addAttribute(model, "ordered", "yes", rootElt);
+        }
+
+        if (isElement && metainf.isNillable(qName)) {
+            XSLTUtils.addAttribute(model, "nillable", "yes", rootElt);
+        }
+
+        //populate all the information
+        populateInfo(metainf, model, rootElt, propertyNames, typeMap,false);
+
+
+        return rootElt;
+    }
+
+    /**
+     *
+     * @param metainf
+     * @param model
+     * @param rootElt
+     * @param propertyNames
+     * @param typeMap
+     * @throws org.apache.axis2.schema.SchemaCompilationException
+     */
+    private void populateInfo(BeanWriterMetaInfoHolder metainf,
+                              Document model,
+                              Element rootElt,
+                              ArrayList propertyNames,
+                              Map typeMap,boolean isInherited)throws SchemaCompilationException{
+        if (metainf.getParent()!=null){
+            populateInfo(metainf.getParent(),model,rootElt,propertyNames,typeMap,true);
+        }
+        addPropertyEntries(metainf, model, rootElt, propertyNames, typeMap,isInherited);
+
+    }
+
+    /**
+     *
+     * @param metainf
+     * @param model
+     * @param rootElt
+     * @param propertyNames
+     * @param typeMap
+     * @throws org.apache.axis2.schema.SchemaCompilationException
+     */
+    private void addPropertyEntries(BeanWriterMetaInfoHolder metainf, Document model, Element
rootElt, ArrayList propertyNames,
+                                    Map typeMap,
+                                    boolean isInherited) throws SchemaCompilationException
{
+        // go in the loop and add the part elements
+        QName[] qNames;
+        if (metainf.isOrdered()) {
+            qNames = metainf.getOrderedQNameArray();
+        } else {
+            qNames = metainf.getQNameArray();
+        }
+
+        QName name;
+        for (int i = 0; i < qNames.length; i++) {
+            Element property = XSLTUtils.addChildElement(model, "property", rootElt);
+            name = qNames[i];
+            String xmlName = name.getLocalPart();
+
+            XSLTUtils.addAttribute(model, "name", xmlName, property);
+
+            XSLTUtils.addAttribute(model, "nsuri", name.getNamespaceURI(), property);
+            String javaName = makeUniqueCStructName(propertyNames, xmlName);
+            XSLTUtils.addAttribute(model, "javaname", javaName, property);
+
+            String javaClassNameForElement = metainf.getClassNameForQName(name);
+
+            if (javaClassNameForElement == null) {
+                throw new SchemaCompilationException(SchemaCompilerMessages.getMessage("schema.typeMissing"));
+            }
+
+            int arrayBracketIndex = -1;
+            arrayBracketIndex = javaClassNameForElement.indexOf('[');
+            if (  arrayBracketIndex > 0) {
+                javaClassNameForElement = javaClassNameForElement.substring(0, arrayBracketIndex
);
+            }
+
+            XSLTUtils.addAttribute(model, "type", javaClassNameForElement, property);
+
+
+            /**
+             * Caps for use in C macros
+             */
+            XSLTUtils.addAttribute(model, "caps-name", xmlName.toUpperCase(), property);
+            XSLTUtils.addAttribute(model, "caps-type", javaClassNameForElement.toUpperCase(),
property);
+
+            if (PrimitiveTypeFinder.isPrimitive(javaClassNameForElement)){
+                XSLTUtils.addAttribute(model, "primitive", "yes", property);
+            }
+            //add an attribute that says the type is default
+            if (isDefault(javaClassNameForElement)){
+                XSLTUtils.addAttribute(model, "default", "yes", property);
+            }
+
+            if (typeMap.containsKey(metainf.getSchemaQNameForQName(name))) {
+                XSLTUtils.addAttribute(model, "ours", "yes", property);
+            }
+
+            if (metainf.getAttributeStatusForQName(name)) {
+                XSLTUtils.addAttribute(model, "attribute", "yes", property);
+            }
+
+            if (metainf.isNillable(name)){
+                XSLTUtils.addAttribute(model, "nillable", "yes", property);
+            }
+
+            String shortTypeName;
+            if (metainf.getSchemaQNameForQName(name) != null) {
+                //see whether the QName is a basetype
+                if (baseTypeMap.containsKey(metainf.getSchemaQNameForQName(name))){
+                    shortTypeName= metainf.getSchemaQNameForQName(name).getLocalPart();
+                }else{
+                    shortTypeName =  getShortTypeName(javaClassNameForElement);
+                }
+            }else{
+                shortTypeName =  getShortTypeName(javaClassNameForElement);
+            }
+            XSLTUtils.addAttribute(model, "shorttypename", shortTypeName, property);
+
+            if (isInherited){
+                XSLTUtils.addAttribute(model, "inherited", "yes", property);
+            }
+
+            if (metainf.getAnyStatusForQName(name)) {
+                XSLTUtils.addAttribute(model, "any", "yes", property);
+            }
+
+            if (metainf.getBinaryStatusForQName(name)) {
+                XSLTUtils.addAttribute(model, "binary", "yes", property);
+            }
+            //put the min occurs count irrespective of whether it's an array or not
+            long minOccurs = metainf.getMinOccurs(name);
+            XSLTUtils.addAttribute(model, "minOccurs", minOccurs + "", property);
+
+
+            if (metainf.getArrayStatusForQName(name)) {
+                String attrName = name.getLocalPart();
+                int arrayTokenStart=attrName.indexOf("Array");
+                if ( arrayTokenStart >= 0 )
+                {
+                    String arrayEle = attrName.substring(0, arrayTokenStart);
+                    XSLTUtils.addAttribute(model, "arrayele", arrayEle, property);
+                    System.out.println(arrayEle);
+                }
+                XSLTUtils.addAttribute(model, "isarray", "yes", property);
+                XSLTUtils.addAttribute(
+                        model,
+                        "arrayBaseType",
+                        javaClassNameForElement,
+                        property);
+
+                long maxOccurs = metainf.getMaxOccurs(name);
+                if (maxOccurs == Long.MAX_VALUE) {
+                    XSLTUtils.addAttribute(model, "unbound", "yes", property);
+                } else {
+                    XSLTUtils.addAttribute(model, "maxOccurs", maxOccurs + "", property);
+                }
+            }
+        }
+    }
+
+    /**
+     * Test whether the given class name matches the default
+     * @param javaClassNameForElement
+     * @return bool
+     */
+    private boolean isDefault(String javaClassNameForElement) {
+        return SchemaCompiler.DEFAULT_CLASS_NAME.equals(javaClassNameForElement)||
+                SchemaCompiler.DEFAULT_CLASS_ARRAY_NAME.equals(javaClassNameForElement);
+    }
+
+
+    /**
+     * Given the xml name, make a unique class name taking into account that some
+     * file systems are case sensitive and some are not.
+     * -Consider the Jax-WS spec for this
+     * @param listOfNames
+     * @param xmlName
+     * @return Returns String.
+     */
+    private String makeUniqueCStructName(List listOfNames, String xmlName) {
+        String javaName;
+        if (JavaUtils.isJavaKeyword(xmlName)) {
+            javaName = JavaUtils.makeNonJavaKeyword(xmlName);
+        } else {
+            //javaName = JavaUtils.capitalizeFirstChar(JavaUtils.xmlNameToJava(xmlName));
+            javaName = xmlName;
+        }
+
+        while (listOfNames.contains(javaName.toLowerCase())) {
+            javaName = javaName + CStructWriter.count++;
+        }
+
+        listOfNames.add(javaName.toLowerCase());
+        return javaName;
+    }
+
+
+    /**
+     * A bit of code from the old code generator. We are better off using the template
+     * engines and such stuff that's already there. But the class writers are hard to be
+     * reused so some code needs to be repeated (atleast a bit)
+     */
+    private void loadTemplate() throws SchemaCompilationException {
+
+        //first get the language specific property map
+        Class clazz = this.getClass();
+        InputStream xslStream;
+        String templateName = javaBeanTemplateName;
+        if (templateName != null) {
+            try {
+                String sourceTemplateName = templateName + "Source.xsl" ;
+                xslStream = clazz.getResourceAsStream(sourceTemplateName);
+                sourceTemplateCache = TransformerFactory.newInstance().newTemplates(new StreamSource(xslStream));
+
+                String headerTemplateName =  templateName + "Header.xsl";
+                xslStream = clazz.getResourceAsStream(headerTemplateName);
+                headerTemplateCache = TransformerFactory.newInstance().newTemplates(new StreamSource(xslStream));
+
+                templateLoaded = true;
+            } catch (TransformerConfigurationException e) {
+                throw new SchemaCompilationException(SchemaCompilerMessages.getMessage("schema.templateLoadException"),
e);
+            }
+        } else {
+            throw new SchemaCompilationException(SchemaCompilerMessages.getMessage("schema.templateNotFoundException"));
+        }
+    }
+
+
+    /**
+     * Creates the output file
+     *
+     * @param fileName
+     * @param extension
+     * @throws Exception
+     */
+    protected File createOutFile(String fileName, String extension) throws Exception {
+        return org.apache.axis2.util.FileWriter.createClassFile(this.rootDir,
+                "",
+                AXIS2_PREFIX + fileName,
+                extension);
+    }
+
+    /**
+     * Writes the output file
+     *
+     * @param doc
+     * @param outputFile
+     * @throws Exception
+     */
+    private void parseSource(Document doc, File outputFile) throws Exception {
+        OutputStream outStream = new FileOutputStream(outputFile);
+        XSLTTemplateProcessor.parse(outStream,
+                doc,
+                this.sourceTemplateCache.newTransformer());
+        outStream.flush();
+        outStream.close();
+
+    }
+
+    /**
+     * Writes the output file
+     *
+     * @param doc
+     * @param outputFile
+     * @throws Exception
+     */
+    private void parseHeader(Document doc, File outputFile) throws Exception {
+        OutputStream outStream = new FileOutputStream(outputFile);
+        XSLTTemplateProcessor.parse(outStream,
+                doc,
+                this.headerTemplateCache.newTransformer());
+        outStream.flush();
+        outStream.close();
+
+    }
+    /**
+     * Get a prefix for a namespace URI.  This method will ALWAYS
+     * return a valid prefix - if the given URI is already mapped in this
+     * serialization, we return the previous prefix.  If it is not mapped,
+     * we will add a new mapping and return a generated prefix of the form
+     * "ns<num>".
+     *
+     * @param uri is the namespace uri
+     * @return Returns prefix.
+     */
+    public String getPrefixForURI(String uri) {
+        return getPrefixForURI(uri, null);
+    }
+
+    /**
+     * Last used index suffix for "ns"
+     */
+    private int lastPrefixIndex = 1;
+
+    /**
+     * Map of namespaces URI to prefix(es)
+     */
+    HashMap mapURItoPrefix = new HashMap();
+    HashMap mapPrefixtoURI = new HashMap();
+
+    /**
+     * Get a prefix for the given namespace URI.  If one has already been
+     * defined in this serialization, use that.  Otherwise, map the passed
+     * default prefix to the URI, and return that.  If a null default prefix
+     * is passed, use one of the form "ns<num>"
+     */
+    public String getPrefixForURI(String uri, String defaultPrefix) {
+        if ((uri == null) || (uri.length() == 0))
+            return null;
+        String prefix = (String) mapURItoPrefix.get(uri);
+        if (prefix == null) {
+            if (defaultPrefix == null || defaultPrefix.length() == 0) {
+                prefix = "ns" + lastPrefixIndex++;
+                while (mapPrefixtoURI.get(prefix) != null) {
+                    prefix = "ns" + lastPrefixIndex++;
+                }
+            } else {
+                prefix = defaultPrefix;
+            }
+            mapPrefixtoURI.put(prefix, uri);
+            mapURItoPrefix.put(uri, prefix);
+        }
+        return prefix;
+    }
+
+    private String getShortTypeName(String typeClassName){
+        if (typeClassName.endsWith("[]")){
+            typeClassName = typeClassName.substring(0,typeClassName.lastIndexOf("["));
+        }
+
+        return typeClassName.substring(typeClassName.lastIndexOf(".")+1, typeClassName.length());
+
+    }
+}



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message