diff options
Diffstat (limited to 'sandbox/tools/xmlfromxsd/src/main/java')
9 files changed, 2239 insertions, 0 deletions
diff --git a/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/CmdLineArgsHandler.java b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/CmdLineArgsHandler.java new file mode 100644 index 0000000000..d4fd17daf8 --- /dev/null +++ b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/CmdLineArgsHandler.java @@ -0,0 +1,27 @@ +/**
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors as applicable
+ *
+ * Licensed 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.tuscany.tools.xmlfromxsd.generate;
+
+/**
+ * This interface is to be implemented by classes that wish to
+ * handle commandline arguments.
+ *
+ */
+public interface CmdLineArgsHandler
+{
+ public void handleArgument(String optionFlag, String argValue) throws IllegalArgumentException;
+}
diff --git a/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/CmdLineArgsProcessor.java b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/CmdLineArgsProcessor.java new file mode 100644 index 0000000000..bdfd1bbe30 --- /dev/null +++ b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/CmdLineArgsProcessor.java @@ -0,0 +1,93 @@ +/**
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors as applicable
+ *
+ * Licensed 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.tuscany.tools.xmlfromxsd.generate;
+
+/**
+ * This class provides a generic command line arguments processing utility. The processArgs
+ * method of this class processes the command line arguments that could contain option flags,
+ * options and values and calls a ArgumentHanlder instance for handling the agruments.
+ *
+ */
+public class CmdLineArgsProcessor
+{
+ private String printUsageMessage = "No hints available on Usage!";
+ private CmdLineArgsHandler argsHandler = null;
+ public static final String HYPEN = "-";
+
+ public void processArgs(String[] args)
+ {
+ try
+ {
+ if (args.length == 0)
+ {
+ printUsage();
+ }
+ else
+ {
+ parseAndHandleArgs(args);
+ }
+ }
+ catch ( Exception e )
+ {
+ System.out.println("Exception in processing argument - " + e);
+ printUsage();
+ }
+
+ }
+
+ public void parseAndHandleArgs(String[] args) throws Exception
+ {
+ int index = 0;
+ while ( index < args.length - 1 )
+ {
+ if ( args[index].startsWith(HYPEN) && !args[ index + 1 ].startsWith(HYPEN) )
+ {
+ argsHandler.handleArgument(args[index].substring(1), args[index + 1]);
+ index = index + 2;
+ }
+ else
+ {
+ throw new IllegalArgumentException("Wrong Usage of options!");
+ }
+ }
+ }
+
+ protected void printUsage()
+ {
+
+ }
+
+ public CmdLineArgsHandler getArgsHandler()
+ {
+ return argsHandler;
+ }
+
+ public void setArgsHandler(CmdLineArgsHandler argsHandler)
+ {
+ this.argsHandler = argsHandler;
+ }
+
+ public String getPrintUsageMessage()
+ {
+ return printUsageMessage;
+ }
+
+ public void setPrintUsageMessage(String printUsageMessage)
+ {
+ this.printUsageMessage = printUsageMessage;
+ }
+}
diff --git a/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/SDObasedXMLGenerator.java b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/SDObasedXMLGenerator.java new file mode 100644 index 0000000000..f415babca2 --- /dev/null +++ b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/SDObasedXMLGenerator.java @@ -0,0 +1,195 @@ +/**
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors as applicable
+ *
+ * Licensed 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.tuscany.tools.xmlfromxsd.generate;
+
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.tuscany.sdo.util.SDOUtil;
+
+import commonj.sdo.DataObject;
+import commonj.sdo.Property;
+import commonj.sdo.Sequence;
+import commonj.sdo.Type;
+import commonj.sdo.helper.CopyHelper;
+import commonj.sdo.helper.DataFactory;
+import commonj.sdo.helper.TypeHelper;
+import commonj.sdo.helper.XMLHelper;
+import commonj.sdo.helper.XSDHelper;
+
+/**
+ * This class generates an XML instance given and XSD. All inputs required by this generator are
+ * set into the XMLFromXSDConfiguration object that is passed in the constructor. This generator
+ * first loads the XSD Types into the TypeHelper. Then for the XSD type for which an XML instnace
+ * is to be created, this generator creates SDOs which are then serialized as XML
+ *
+ */
+public class SDObasedXMLGenerator implements XMLGenerator
+{
+ private XMLfromXSDConfiguration config = null;
+
+ private TypeHelper typeHelper = null; //SDOUtil.createTypeHelper();
+
+ private XSDHelper xsdHelper = null; //SDOUtil.createXSDHelper(typeHelper);
+
+ private XMLHelper xmlHelper = null;//SDOUtil.createXMLHelper(typeHelper);
+
+ private Hashtable complexTypesMap = new Hashtable();
+
+ DataFactory dataFactory = SDOUtil.createDataFactory(typeHelper);
+
+ public SDObasedXMLGenerator(XMLfromXSDConfiguration config)
+ {
+ this.config = config;
+ // config.setXsdInputStream(getClass().getResource(conf).openStream());
+ }
+
+
+
+ public void generateXML(XMLfromXSDConfiguration config) throws Exception
+ {
+ this.config = config;
+ generateXML();
+ }
+
+
+
+ public void generateXML() throws Exception
+ {
+ typeHelper = SDOUtil.createTypeHelper();
+ xsdHelper = SDOUtil.createXSDHelper(typeHelper);
+
+ if ( config != null )
+ {
+ List types = xsdHelper.define(config.getXsdInputStream(), null);
+ Type type = typeHelper.getType(config.getSchemaTypeNamespaceURI(),
+ config.getSchemaTypeName());
+
+ if ( type != null )
+ {
+ Object instance = createInstance(type, null);
+ if ( instance != null )
+ {
+ xmlHelper = SDOUtil.createXMLHelper(typeHelper);
+ xmlHelper.save((DataObject) instance,
+ config.getRootElementNamespaceURI(),
+ config.getRootElementLocalName(), config.getXmlOutputStream());
+ }
+ }
+ else
+ {
+ throw new IllegalArgumentException("Incorrect input of SchemaType Namespace / SchemaType to be instantiated as XML!");
+ }
+ }
+ else
+ {
+ throw new Exception("Generation Configuraiton not set - no instnace of XMLFromXSDConfiguration found!");
+ }
+ }
+
+ protected Object createSimpleDataObject(Type type, Object defaultValue)
+ {
+ // FIXME: We need to handle well-know simple types
+ //return SDOUtil.createFromString(type, "0");
+ try
+ {
+ return SDOUtil.createFromString(type,"");
+ }
+ catch ( NumberFormatException nfe )
+ {
+ return SDOUtil.createFromString(type,"0");
+ }
+
+ }
+
+ protected Object createComplexDataObject(Type type, Object defaultValue)
+ {
+ // Type references can be recursive, we need to avoid infinite loop
+ DataObject dataObject = (DataObject) complexTypesMap.get(type);
+ if (dataObject != null)
+ {
+ dataObject = CopyHelper.INSTANCE.copy((DataObject) dataObject);
+ } else
+ {
+ dataObject = dataFactory.create(type);
+ complexTypesMap.put(type, dataObject);
+
+ List properties = type.getProperties();
+ for ( Iterator i = properties.iterator(); i.hasNext(); )
+ {
+ Property property = (Property) i.next();
+ if (!property.isReadOnly())
+ {
+ if (property.isMany())
+ {
+ Object values = dataObject.get(property);
+ if (values instanceof Sequence)
+ {
+ // NOP
+ }
+ if (values instanceof List)
+ {
+ ((List) values).add(createInstance(property
+ .getType(), null));
+ }
+ } else
+ {
+ dataObject.set(property, createInstance(property
+ .getType(), property.getDefault()));
+ }
+ }
+ }
+ }
+ return dataObject;
+ }
+
+ public Object createInstance(Type type, Object defaultValue)
+ {
+ Object dataObject = null;
+ if (type != null)
+ {
+ if (type.isDataType())
+ {
+ if (defaultValue != null)
+ {
+ dataObject = defaultValue;
+ } else
+ {
+ dataObject = createSimpleDataObject(type, defaultValue);
+ }
+
+ } else
+ {
+ dataObject = createComplexDataObject(type, defaultValue);
+ }
+ }
+ return dataObject;
+ }
+
+ public XMLfromXSDConfiguration getConfig()
+ {
+ return config;
+ }
+
+ public void setConfig(XMLfromXSDConfiguration config)
+ {
+ this.config = config;
+ }
+}
diff --git a/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/TuscanySampleXmlUtil.java b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/TuscanySampleXmlUtil.java new file mode 100644 index 0000000000..7a4ea49a81 --- /dev/null +++ b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/TuscanySampleXmlUtil.java @@ -0,0 +1,1218 @@ +package org.apache.tuscany.tools.xmlfromxsd.generate;
+
+import org.apache.xmlbeans.SchemaType;
+import org.apache.xmlbeans.XmlCursor;
+import org.apache.xmlbeans.SchemaParticle;
+import org.apache.xmlbeans.SchemaLocalElement;
+import org.apache.xmlbeans.SchemaProperty;
+import org.apache.xmlbeans.GDuration;
+import org.apache.xmlbeans.GDurationBuilder;
+import org.apache.xmlbeans.GDate;
+import org.apache.xmlbeans.GDateBuilder;
+import org.apache.xmlbeans.XmlAnySimpleType;
+import org.apache.xmlbeans.SimpleValue;
+import org.apache.xmlbeans.XmlOptions;
+import org.apache.xmlbeans.XmlObject;
+import org.apache.xmlbeans.XmlInteger;
+import org.apache.xmlbeans.XmlDate;
+import org.apache.xmlbeans.XmlDateTime;
+import org.apache.xmlbeans.XmlTime;
+import org.apache.xmlbeans.XmlGYear;
+import org.apache.xmlbeans.XmlGYearMonth;
+import org.apache.xmlbeans.XmlGMonth;
+import org.apache.xmlbeans.XmlGMonthDay;
+import org.apache.xmlbeans.XmlGDay;
+import org.apache.xmlbeans.XmlDecimal;
+import org.apache.xmlbeans.XmlDuration;
+import org.apache.xmlbeans.soap.SchemaWSDLArrayType;
+import org.apache.xmlbeans.soap.SOAPArrayType;
+import org.apache.xmlbeans.impl.util.Base64;
+import org.apache.xmlbeans.impl.util.HexBin;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Random;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Arrays;
+
+import javax.xml.namespace.QName;
+
+
+/**
+ * This class is a replication of the XMLBeans SampleXMLutil class. This replication
+ * is required to overide the XMLBeans behaviour of this class in certain places. Since
+ * most methods of the XMLBeans implementation of this class is private, no overiding
+ * has been possible using inheritance. Hence this replication.
+ *
+ */
+public class TuscanySampleXmlUtil
+{
+ private static final String BLANK_STRING = " ";
+ private boolean generate_sample_data = false;
+ private boolean _soapEnc;
+ private static final int MAX_ELEMENTS = 1000;
+ private int _nElements;
+ boolean flag = true;
+
+ private TuscanySampleXmlUtil(boolean soapEnc)
+ {
+ _soapEnc = soapEnc;
+ }
+
+ public TuscanySampleXmlUtil()
+ {
+ this(false);
+ }
+
+ public String createSampleForType(SchemaType sType)
+ {
+ XmlObject object = XmlObject.Factory.newInstance();
+ XmlCursor cursor = object.newCursor();
+ // Skip the document node
+ cursor.toNextToken();
+ // Using the type and the cursor, call the utility method to get a
+ // sample XML payload for that Schema element
+ createSampleForType(sType, cursor);
+ // Cursor now contains the sample payload
+ // Pretty print the result. Note that the cursor is positioned at the
+ // end of the doc so we use the original xml object that the cursor was
+ // created upon to do the xmlText() against.
+ XmlOptions options = new XmlOptions();
+ options.put(XmlOptions.SAVE_PRETTY_PRINT);
+ options.put(XmlOptions.SAVE_PRETTY_PRINT_INDENT, 2);
+ options.put(XmlOptions.SAVE_AGGRESSIVE_NAMESPACES);
+ String result = object.xmlText(options);
+ return result;
+ }
+
+ Random _picker = new Random(1);
+
+ /**
+ * Cursor position
+ * Before:
+ * <theElement>^</theElement>
+ * After:
+ * <theElement><lots of stuff/>^</theElement>
+ */
+ private void createSampleForType(SchemaType stype, XmlCursor xmlc)
+ {
+ if (_typeStack.contains( stype ) )
+ //if ( !flag )
+ return;
+ //else
+ // flag = false;
+
+ _typeStack.add( stype );
+
+ try
+ {
+ if (stype.isSimpleType() || stype.isURType())
+ {
+ processSimpleType(stype, xmlc);
+ return;
+ }
+
+ // complex Type
+ // <theElement>^</theElement>
+ processAttributes(stype, xmlc);
+
+ // <theElement attri1="string">^</theElement>
+ switch (stype.getContentType())
+ {
+ case SchemaType.NOT_COMPLEX_TYPE :
+ case SchemaType.EMPTY_CONTENT :
+ // noop
+ break;
+ case SchemaType.SIMPLE_CONTENT :
+ {
+ processSimpleType(stype, xmlc);
+ }
+ break;
+ case SchemaType.MIXED_CONTENT :
+ if ( isGenerate_sample_data() )
+ xmlc.insertChars(pick(WORDS) + " ");
+ if (stype.getContentModel() != null)
+ {
+ processParticle(stype.getContentModel(), xmlc, true);
+ }
+ if ( isGenerate_sample_data() )
+ xmlc.insertChars(pick(WORDS));
+
+ break;
+ case SchemaType.ELEMENT_CONTENT :
+ if (stype.getContentModel() != null)
+ {
+ processParticle(stype.getContentModel(), xmlc, false);
+ }
+ break;
+ }
+ }
+ finally
+ {
+ _typeStack.remove( _typeStack.size() - 1 );
+ }
+ }
+
+ private void processSimpleType(SchemaType stype, XmlCursor xmlc)
+ {
+ String sample = sampleDataForSimpleType(stype);
+ xmlc.insertChars(sample);
+
+ }
+
+ private String sampleDataForSimpleType(SchemaType sType)
+ {
+ if ( isGenerate_sample_data() )
+ {
+ return generateSampleDataForSimpleType(sType);
+ }
+ else
+ {
+ return BLANK_STRING;
+ }
+ }
+
+ private String generateSampleDataForSimpleType(SchemaType sType)
+ {
+ if (XmlObject.type.equals(sType))
+ return "anyType";
+
+ if (XmlAnySimpleType.type.equals(sType))
+ return "anySimpleType";
+
+ if (sType.getSimpleVariety() == SchemaType.LIST)
+ {
+ SchemaType itemType = sType.getListItemType();
+ StringBuffer sb = new StringBuffer();
+ int length = pickLength(sType);
+ if (length > 0)
+ sb.append(sampleDataForSimpleType(itemType));
+ for (int i = 1; i < length; i += 1)
+ {
+ sb.append(' ');
+ sb.append(sampleDataForSimpleType(itemType));
+ }
+ return sb.toString();
+ }
+
+ if (sType.getSimpleVariety() == SchemaType.UNION)
+ {
+ SchemaType[] possibleTypes = sType.getUnionConstituentTypes();
+ if (possibleTypes.length == 0)
+ return "";
+ return sampleDataForSimpleType(possibleTypes[pick(possibleTypes.length)]);
+ }
+
+ XmlAnySimpleType[] enumValues = sType.getEnumerationValues();
+ if (enumValues != null && enumValues.length > 0)
+ {
+ return enumValues[pick(enumValues.length)].getStringValue();
+ }
+
+ switch (sType.getPrimitiveType().getBuiltinTypeCode())
+ {
+ default:
+ case SchemaType.BTC_NOT_BUILTIN:
+ return "";
+
+ case SchemaType.BTC_ANY_TYPE:
+ case SchemaType.BTC_ANY_SIMPLE:
+ return "anything";
+
+ case SchemaType.BTC_BOOLEAN:
+ return pick(2) == 0 ? "true" : "false";
+
+ case SchemaType.BTC_BASE_64_BINARY:
+ {
+ String result = null;
+ try
+ { result = new String(Base64.encode(formatToLength(pick(WORDS), sType).getBytes("utf-8"))); }
+ catch (java.io.UnsupportedEncodingException e)
+ { /* Can't possibly happen */ }
+ return result;
+ }
+
+ case SchemaType.BTC_HEX_BINARY:
+ return HexBin.encode(formatToLength(pick(WORDS), sType));
+
+ case SchemaType.BTC_ANY_URI:
+ return formatToLength("http://www." + pick(DNS1) + "." + pick(DNS2) + "/" + pick(WORDS) + "/" + pick(WORDS), sType);
+
+ case SchemaType.BTC_QNAME:
+ return formatToLength("qname", sType);
+
+ case SchemaType.BTC_NOTATION:
+ return formatToLength("notation", sType);
+
+ case SchemaType.BTC_FLOAT:
+ return "1.5E2";
+ case SchemaType.BTC_DOUBLE:
+ return "1.051732E7";
+ case SchemaType.BTC_DECIMAL:
+ switch (closestBuiltin(sType).getBuiltinTypeCode())
+ {
+ case SchemaType.BTC_SHORT:
+ return formatDecimal("1", sType);
+ case SchemaType.BTC_UNSIGNED_SHORT:
+ return formatDecimal("5", sType);
+ case SchemaType.BTC_BYTE:
+ return formatDecimal("2", sType);
+ case SchemaType.BTC_UNSIGNED_BYTE:
+ return formatDecimal("6", sType);
+ case SchemaType.BTC_INT:
+ return formatDecimal("3", sType);
+ case SchemaType.BTC_UNSIGNED_INT:
+ return formatDecimal("7", sType);
+ case SchemaType.BTC_LONG:
+ return formatDecimal("10", sType);
+ case SchemaType.BTC_UNSIGNED_LONG:
+ return formatDecimal("11", sType);
+ case SchemaType.BTC_INTEGER:
+ return formatDecimal("100", sType);
+ case SchemaType.BTC_NON_POSITIVE_INTEGER:
+ return formatDecimal("-200", sType);
+ case SchemaType.BTC_NEGATIVE_INTEGER:
+ return formatDecimal("-201", sType);
+ case SchemaType.BTC_NON_NEGATIVE_INTEGER:
+ return formatDecimal("200", sType);
+ case SchemaType.BTC_POSITIVE_INTEGER:
+ return formatDecimal("201", sType);
+ default:
+ case SchemaType.BTC_DECIMAL:
+ return formatDecimal("1000.00", sType);
+ }
+
+ case SchemaType.BTC_STRING:
+ {
+ String result;
+ switch (closestBuiltin(sType).getBuiltinTypeCode())
+ {
+ case SchemaType.BTC_STRING:
+ case SchemaType.BTC_NORMALIZED_STRING:
+ result = "string";
+ break;
+
+ case SchemaType.BTC_TOKEN:
+ result = "token";
+ break;
+
+ default:
+ result = "string";
+ break;
+ }
+
+ return formatToLength(result, sType);
+ }
+
+ case SchemaType.BTC_DURATION:
+ return formatDuration(sType);
+
+ case SchemaType.BTC_DATE_TIME:
+ case SchemaType.BTC_TIME:
+ case SchemaType.BTC_DATE:
+ case SchemaType.BTC_G_YEAR_MONTH:
+ case SchemaType.BTC_G_YEAR:
+ case SchemaType.BTC_G_MONTH_DAY:
+ case SchemaType.BTC_G_DAY:
+ case SchemaType.BTC_G_MONTH:
+ return formatDate(sType);
+ }
+ }
+
+ // a bit from the Aenid
+ public static final String[] WORDS = new String[]
+ {
+ "ipsa", "iovis", "rapidum", "iaculata", "e", "nubibus", "ignem",
+ "disiecitque", "rates", "evertitque", "aequora", "ventis",
+ "illum", "exspirantem", "transfixo", "pectore", "flammas",
+ "turbine", "corripuit", "scopuloque", "infixit", "acuto",
+ "ast", "ego", "quae", "divum", "incedo", "regina", "iovisque",
+ "et", "soror", "et", "coniunx", "una", "cum", "gente", "tot", "annos",
+ "bella", "gero", "et", "quisquam", "numen", "iunonis", "adorat",
+ "praeterea", "aut", "supplex", "aris", "imponet", "honorem",
+ "talia", "flammato", "secum", "dea", "corde", "volutans",
+ "nimborum", "in", "patriam", "loca", "feta", "furentibus", "austris",
+ "aeoliam", "venit", "hic", "vasto", "rex", "aeolus", "antro",
+ "luctantis", "ventos", "tempestatesque", "sonoras",
+ "imperio", "premit", "ac", "vinclis", "et", "carcere", "frenat",
+ "illi", "indignantes", "magno", "cum", "murmure", "montis",
+ "circum", "claustra", "fremunt", "celsa", "sedet", "aeolus", "arce",
+ "sceptra", "tenens", "mollitque", "animos", "et", "temperat", "iras",
+ "ni", "faciat", "maria", "ac", "terras", "caelumque", "profundum",
+ "quippe", "ferant", "rapidi", "secum", "verrantque", "per", "auras",
+ "sed", "pater", "omnipotens", "speluncis", "abdidit", "atris",
+ "hoc", "metuens", "molemque", "et", "montis", "insuper", "altos",
+ "imposuit", "regemque", "dedit", "qui", "foedere", "certo",
+ "et", "premere", "et", "laxas", "sciret", "dare", "iussus", "habenas",
+ };
+
+
+
+ private static final String[] DNS1 = new String[] { "corp", "your", "my", "sample", "company", "test", "any" };
+ private static final String[] DNS2 = new String[] { "com", "org", "com", "gov", "org", "com", "org", "com", "edu" };
+
+ private int pick(int n)
+ {
+ return _picker.nextInt(n);
+ }
+
+ private String pick(String[] a)
+ {
+ return a[pick(a.length)];
+ }
+
+ private String pick(String[] a, int count)
+ {
+ if (count <= 0)
+ return "";
+
+ int i = pick(a.length);
+ StringBuffer sb = new StringBuffer(a[i]);
+ while (count-- > 0)
+ {
+ i += 1;
+ if (i >= a.length)
+ i = 0;
+ sb.append(' ');
+ sb.append(a[i]);
+ }
+ return sb.toString();
+ }
+
+ private String pickDigits(int digits)
+ {
+ StringBuffer sb = new StringBuffer();
+ while (digits-- > 0)
+ sb.append(Integer.toString(pick(10)));
+ return sb.toString();
+ }
+
+ private int pickLength(SchemaType sType)
+ {
+ XmlInteger length = (XmlInteger) sType.getFacet(SchemaType.FACET_LENGTH);
+ if (length != null)
+ return length.getBigIntegerValue().intValue();
+ XmlInteger min = (XmlInteger) sType.getFacet(SchemaType.FACET_MIN_LENGTH);
+ XmlInteger max = (XmlInteger) sType.getFacet(SchemaType.FACET_MAX_LENGTH);
+ int minInt, maxInt;
+ if (min == null)
+ minInt = 0;
+ else
+ minInt = min.getBigIntegerValue().intValue();
+ if (max == null)
+ maxInt = Integer.MAX_VALUE;
+ else
+ maxInt = max.getBigIntegerValue().intValue();
+ // We try to keep the length of the array within reasonable limits,
+ // at least 1 item and at most 3 if possible
+ if (minInt == 0 && maxInt >= 1)
+ minInt = 1;
+ if (maxInt > minInt + 2)
+ maxInt = minInt + 2;
+ if (maxInt < minInt)
+ maxInt = minInt;
+ return minInt + pick(maxInt-minInt);
+ }
+
+ /**
+ * Formats a given string to the required length, using the following operations:
+ * - append the source string to itself as necessary to pass the minLength;
+ * - truncate the result of previous step, if necessary, to keep it within minLength.
+ */
+ private String formatToLength(String s, SchemaType sType)
+ {
+ String result = s;
+ try
+ {
+ SimpleValue min = (SimpleValue)sType.getFacet(SchemaType.FACET_LENGTH);
+ if (min == null)
+ min = (SimpleValue)sType.getFacet(SchemaType.FACET_MIN_LENGTH);
+ if (min != null)
+ {
+ int len = min.getIntValue();
+ while (result.length() < len)
+ result = result + result;
+ }
+ SimpleValue max = (SimpleValue)sType.getFacet(SchemaType.FACET_LENGTH);
+ if (max == null)
+ max = (SimpleValue)sType.getFacet(SchemaType.FACET_MAX_LENGTH);
+ if (max != null)
+ {
+ int len = max.getIntValue();
+ if (result.length() > len)
+ result = result.substring(0, len);
+ }
+ }
+ catch (Exception e) // intValue can be out of range
+ {
+ }
+ return result;
+ }
+
+ private String formatDecimal(String start, SchemaType sType)
+ {
+ BigDecimal result = new BigDecimal(start);
+ XmlDecimal xmlD;
+ xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ BigDecimal min = xmlD != null ? xmlD.getBigDecimalValue() : null;
+ xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ BigDecimal max = xmlD != null ? xmlD.getBigDecimalValue() : null;
+ boolean minInclusive = true, maxInclusive = true;
+ xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ if (xmlD != null)
+ {
+ BigDecimal minExcl = xmlD.getBigDecimalValue();
+ if (min == null || min.compareTo(minExcl) < 0)
+ {
+ min = minExcl;
+ minInclusive = false;
+ }
+ }
+ xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ if (xmlD != null)
+ {
+ BigDecimal maxExcl = xmlD.getBigDecimalValue();
+ if (max == null || max.compareTo(maxExcl) > 0)
+ {
+ max = maxExcl;
+ maxInclusive = false;
+ }
+ }
+ xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_TOTAL_DIGITS);
+ int totalDigits = -1;
+ if (xmlD != null)
+ {
+ totalDigits = xmlD.getBigDecimalValue().intValue();
+
+ StringBuffer sb = new StringBuffer(totalDigits);
+ for (int i = 0; i < totalDigits; i++)
+ sb.append('9');
+ BigDecimal digitsLimit = new BigDecimal(sb.toString());
+ if (max != null && max.compareTo(digitsLimit) > 0)
+ {
+ max = digitsLimit;
+ maxInclusive = true;
+ }
+ digitsLimit = digitsLimit.negate();
+ if (min != null && min.compareTo(digitsLimit) < 0)
+ {
+ min = digitsLimit;
+ minInclusive = true;
+ }
+ }
+
+ int sigMin = min == null ? 1 : result.compareTo(min);
+ int sigMax = max == null ? -1 : result.compareTo(max);
+ boolean minOk = sigMin > 0 || sigMin == 0 && minInclusive;
+ boolean maxOk = sigMax < 0 || sigMax == 0 && maxInclusive;
+
+ // Compute the minimum increment
+ xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_FRACTION_DIGITS);
+ int fractionDigits = -1;
+ BigDecimal increment;
+ if (xmlD == null)
+ increment = new BigDecimal(1);
+ else
+ {
+ fractionDigits = xmlD.getBigDecimalValue().intValue();
+ if (fractionDigits > 0)
+ {
+ StringBuffer sb = new StringBuffer("0.");
+ for (int i = 1; i < fractionDigits; i++)
+ sb.append('0');
+ sb.append('1');
+ increment = new BigDecimal(sb.toString());
+ }
+ else
+ increment = new BigDecimal(1.0);
+ }
+
+ if (minOk && maxOk)
+ {
+ // OK
+ }
+ else if (minOk && !maxOk)
+ {
+ // TOO BIG
+ if (maxInclusive)
+ result = max;
+ else
+ result = max.subtract(increment);
+ }
+ else if (!minOk && maxOk)
+ {
+ // TOO SMALL
+ if (minInclusive)
+ result = min;
+ else
+ result = min.add(increment);
+ }
+ else
+ {
+ // MIN > MAX!!
+ }
+
+ // We have the number
+ // Adjust the scale according to the totalDigits and fractionDigits
+ int digits = 0;
+ BigDecimal ONE = new BigDecimal(BigInteger.ONE);
+ for (BigDecimal n = result; n.abs().compareTo(ONE) >= 0; digits++)
+ n = n.movePointLeft(1);
+
+ if (fractionDigits > 0)
+ if (totalDigits >= 0)
+ result.setScale(Math.max(fractionDigits, totalDigits - digits));
+ else
+ result.setScale(fractionDigits);
+ else if (fractionDigits == 0)
+ result.setScale(0);
+
+ return result.toString();
+ }
+
+ private String formatDuration(SchemaType sType)
+ {
+ XmlDuration d =
+ (XmlDuration) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ GDuration minInclusive = null;
+ if (d != null)
+ minInclusive = d.getGDurationValue();
+
+ d = (XmlDuration) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ GDuration maxInclusive = null;
+ if (d != null)
+ maxInclusive = d.getGDurationValue();
+
+ d = (XmlDuration) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ GDuration minExclusive = null;
+ if (d != null)
+ minExclusive = d.getGDurationValue();
+
+ d = (XmlDuration) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ GDuration maxExclusive = null;
+ if (d != null)
+ maxExclusive = d.getGDurationValue();
+
+ GDurationBuilder gdurb = new GDurationBuilder();
+ BigInteger min, max;
+
+ gdurb.setSecond(pick(800000));
+ gdurb.setMonth(pick(20));
+
+ // Years
+ // Months
+ // Days
+ // Hours
+ // Minutes
+ // Seconds
+ // Fractions
+ if (minInclusive != null)
+ {
+ if (gdurb.getYear() < minInclusive.getYear())
+ gdurb.setYear(minInclusive.getYear());
+ if (gdurb.getMonth() < minInclusive.getMonth())
+ gdurb.setMonth(minInclusive.getMonth());
+ if (gdurb.getDay() < minInclusive.getDay())
+ gdurb.setDay(minInclusive.getDay());
+ if (gdurb.getHour() < minInclusive.getHour())
+ gdurb.setHour(minInclusive.getHour());
+ if (gdurb.getMinute() < minInclusive.getMinute())
+ gdurb.setMinute(minInclusive.getMinute());
+ if (gdurb.getSecond() < minInclusive.getSecond())
+ gdurb.setSecond(minInclusive.getSecond());
+ if (gdurb.getFraction().compareTo(minInclusive.getFraction()) < 0)
+ gdurb.setFraction(minInclusive.getFraction());
+ }
+
+ if (maxInclusive != null)
+ {
+ if (gdurb.getYear() > maxInclusive.getYear())
+ gdurb.setYear(maxInclusive.getYear());
+ if (gdurb.getMonth() > maxInclusive.getMonth())
+ gdurb.setMonth(maxInclusive.getMonth());
+ if (gdurb.getDay() > maxInclusive.getDay())
+ gdurb.setDay(maxInclusive.getDay());
+ if (gdurb.getHour() > maxInclusive.getHour())
+ gdurb.setHour(maxInclusive.getHour());
+ if (gdurb.getMinute() > maxInclusive.getMinute())
+ gdurb.setMinute(maxInclusive.getMinute());
+ if (gdurb.getSecond() > maxInclusive.getSecond())
+ gdurb.setSecond(maxInclusive.getSecond());
+ if (gdurb.getFraction().compareTo(maxInclusive.getFraction()) > 0)
+ gdurb.setFraction(maxInclusive.getFraction());
+ }
+
+ if (minExclusive != null)
+ {
+ if (gdurb.getYear() <= minExclusive.getYear())
+ gdurb.setYear(minExclusive.getYear()+1);
+ if (gdurb.getMonth() <= minExclusive.getMonth())
+ gdurb.setMonth(minExclusive.getMonth()+1);
+ if (gdurb.getDay() <= minExclusive.getDay())
+ gdurb.setDay(minExclusive.getDay()+1);
+ if (gdurb.getHour() <= minExclusive.getHour())
+ gdurb.setHour(minExclusive.getHour()+1);
+ if (gdurb.getMinute() <= minExclusive.getMinute())
+ gdurb.setMinute(minExclusive.getMinute()+1);
+ if (gdurb.getSecond() <= minExclusive.getSecond())
+ gdurb.setSecond(minExclusive.getSecond()+1);
+ if (gdurb.getFraction().compareTo(minExclusive.getFraction()) <= 0)
+ gdurb.setFraction(minExclusive.getFraction().add(new BigDecimal(0.001)));
+ }
+
+ if (maxExclusive != null)
+ {
+ if (gdurb.getYear() > maxExclusive.getYear())
+ gdurb.setYear(maxExclusive.getYear());
+ if (gdurb.getMonth() > maxExclusive.getMonth())
+ gdurb.setMonth(maxExclusive.getMonth());
+ if (gdurb.getDay() > maxExclusive.getDay())
+ gdurb.setDay(maxExclusive.getDay());
+ if (gdurb.getHour() > maxExclusive.getHour())
+ gdurb.setHour(maxExclusive.getHour());
+ if (gdurb.getMinute() > maxExclusive.getMinute())
+ gdurb.setMinute(maxExclusive.getMinute());
+ if (gdurb.getSecond() > maxExclusive.getSecond())
+ gdurb.setSecond(maxExclusive.getSecond());
+ if (gdurb.getFraction().compareTo(maxExclusive.getFraction()) > 0)
+ gdurb.setFraction(maxExclusive.getFraction());
+ }
+
+ gdurb.normalize();
+ return gdurb.toString();
+ }
+
+ private String formatDate(SchemaType sType)
+ {
+ GDateBuilder gdateb = new GDateBuilder(new Date(1000L * pick(365 * 24 * 60 * 60) + (30L + pick(20)) * 365 * 24 * 60 * 60 * 1000));
+ GDate min = null, max = null;
+ GDate temp;
+
+ // Find the min and the max according to the type
+ switch (sType.getPrimitiveType().getBuiltinTypeCode())
+ {
+ case SchemaType.BTC_DATE_TIME:
+ {
+ XmlDateTime x = (XmlDateTime) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ if (x != null)
+ min = x.getGDateValue();
+ x = (XmlDateTime) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ if (x != null)
+ if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
+ min = x.getGDateValue();
+
+ x = (XmlDateTime) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ if (x != null)
+ max = x.getGDateValue();
+ x = (XmlDateTime) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ if (x != null)
+ if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
+ max = x.getGDateValue();
+ break;
+ }
+ case SchemaType.BTC_TIME:
+ {
+ XmlTime x = (XmlTime) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ if (x != null)
+ min = x.getGDateValue();
+ x = (XmlTime) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ if (x != null)
+ if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
+ min = x.getGDateValue();
+
+ x = (XmlTime) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ if (x != null)
+ max = x.getGDateValue();
+ x = (XmlTime) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ if (x != null)
+ if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
+ max = x.getGDateValue();
+ break;
+ }
+ case SchemaType.BTC_DATE:
+ {
+ XmlDate x = (XmlDate) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ if (x != null)
+ min = x.getGDateValue();
+ x = (XmlDate) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ if (x != null)
+ if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
+ min = x.getGDateValue();
+
+ x = (XmlDate) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ if (x != null)
+ max = x.getGDateValue();
+ x = (XmlDate) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ if (x != null)
+ if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
+ max = x.getGDateValue();
+ break;
+ }
+ case SchemaType.BTC_G_YEAR_MONTH:
+ {
+ XmlGYearMonth x = (XmlGYearMonth) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ if (x != null)
+ min = x.getGDateValue();
+ x = (XmlGYearMonth) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ if (x != null)
+ if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
+ min = x.getGDateValue();
+
+ x = (XmlGYearMonth) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ if (x != null)
+ max = x.getGDateValue();
+ x = (XmlGYearMonth) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ if (x != null)
+ if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
+ max = x.getGDateValue();
+ break;
+ }
+ case SchemaType.BTC_G_YEAR:
+ {
+ XmlGYear x = (XmlGYear) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ if (x != null)
+ min = x.getGDateValue();
+ x = (XmlGYear) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ if (x != null)
+ if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
+ min = x.getGDateValue();
+
+ x = (XmlGYear) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ if (x != null)
+ max = x.getGDateValue();
+ x = (XmlGYear) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ if (x != null)
+ if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
+ max = x.getGDateValue();
+ break;
+ }
+ case SchemaType.BTC_G_MONTH_DAY:
+ {
+ XmlGMonthDay x = (XmlGMonthDay) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ if (x != null)
+ min = x.getGDateValue();
+ x = (XmlGMonthDay) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ if (x != null)
+ if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
+ min = x.getGDateValue();
+
+ x = (XmlGMonthDay) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ if (x != null)
+ max = x.getGDateValue();
+ x = (XmlGMonthDay) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ if (x != null)
+ if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
+ max = x.getGDateValue();
+ break;
+ }
+ case SchemaType.BTC_G_DAY:
+ {
+ XmlGDay x = (XmlGDay) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ if (x != null)
+ min = x.getGDateValue();
+ x = (XmlGDay) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ if (x != null)
+ if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
+ min = x.getGDateValue();
+
+ x = (XmlGDay) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ if (x != null)
+ max = x.getGDateValue();
+ x = (XmlGDay) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ if (x != null)
+ if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
+ max = x.getGDateValue();
+ break;
+ }
+ case SchemaType.BTC_G_MONTH:
+ {
+ XmlGMonth x = (XmlGMonth) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
+ if (x != null)
+ min = x.getGDateValue();
+ x = (XmlGMonth) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
+ if (x != null)
+ if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
+ min = x.getGDateValue();
+
+ x = (XmlGMonth) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
+ if (x != null)
+ max = x.getGDateValue();
+ x = (XmlGMonth) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
+ if (x != null)
+ if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
+ max = x.getGDateValue();
+ break;
+ }
+ }
+
+ if (min != null && max == null)
+ {
+ if (min.compareToGDate(gdateb) >= 0)
+ {
+ // Reset the date to min + (1-8) hours
+ Calendar c = gdateb.getCalendar();
+ c.add(Calendar.HOUR_OF_DAY, pick(8));
+ gdateb = new GDateBuilder(c);
+ }
+ }
+ else if (min == null && max != null)
+ {
+ if (max.compareToGDate(gdateb) <= 0)
+ {
+ // Reset the date to max - (1-8) hours
+ Calendar c = gdateb.getCalendar();
+ c.add(Calendar.HOUR_OF_DAY, 0-pick(8));
+ gdateb = new GDateBuilder(c);
+ }
+ }
+ else if (min != null && max != null)
+ {
+ if (min.compareToGDate(gdateb) >= 0 || max.compareToGDate(gdateb) <= 0)
+ {
+ // Find a date between the two
+ Calendar c = min.getCalendar();
+ Calendar cmax = max.getCalendar();
+ c.add(Calendar.HOUR_OF_DAY, 1);
+ if (c.after(cmax))
+ {
+ c.add(Calendar.HOUR_OF_DAY, -1);
+ c.add(Calendar.MINUTE, 1);
+ if (c.after(cmax))
+ {
+ c.add(Calendar.MINUTE, -1);
+ c.add(Calendar.SECOND, 1);
+ if (c.after(cmax))
+ {
+ c.add(Calendar.SECOND, -1);
+ c.add(Calendar.MILLISECOND, 1);
+ if (c.after(cmax))
+ c.add(Calendar.MILLISECOND, -1);
+ }
+ }
+ }
+ gdateb = new GDateBuilder(c);
+ }
+ }
+
+ gdateb.setBuiltinTypeCode(sType.getPrimitiveType().getBuiltinTypeCode());
+ if (pick(2) == 0)
+ gdateb.clearTimeZone();
+ return gdateb.toString();
+ }
+
+ private SchemaType closestBuiltin(SchemaType sType)
+ {
+ while (!sType.isBuiltinType())
+ sType = sType.getBaseType();
+ return sType;
+ }
+
+ /**
+ * Cracks a combined QName of the form URL:localname
+ */
+ public static QName crackQName(String qName)
+ {
+ String ns;
+ String name;
+
+ int index = qName.lastIndexOf( ':' );
+ if (index >= 0)
+ {
+ ns = qName.substring( 0, index );
+ name = qName.substring( index + 1);
+ }
+ else
+ {
+ ns = "";
+ name = qName;
+ }
+
+ return new QName(ns, name);
+ }
+
+
+ /**
+ * Cursor position:
+ * Before this call:
+ * <outer><foo/>^</outer> (cursor at the ^)
+ * After this call:
+ * <<outer><foo/><bar/>som text<etc/>^</outer>
+ */
+ private void processParticle(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
+ {
+ int loop = determineMinMaxForSample(sp, xmlc);
+
+ while (loop-- > 0)
+ {
+ switch (sp.getParticleType())
+ {
+ case (SchemaParticle.ELEMENT) :
+ processElement(sp, xmlc, mixed);
+ break;
+ case (SchemaParticle.SEQUENCE) :
+ processSequence(sp, xmlc, mixed);
+ break;
+ case (SchemaParticle.CHOICE) :
+ processChoice(sp, xmlc, mixed);
+ break;
+ case (SchemaParticle.ALL) :
+ processAll(sp, xmlc, mixed);
+ break;
+ case (SchemaParticle.WILDCARD) :
+ processWildCard(sp, xmlc, mixed);
+ break;
+ default :
+ // throw new Exception("No Match on Schema Particle Type: " + String.valueOf(sp.getParticleType()));
+ }
+ }
+ }
+
+ private int determineMinMaxForSample(SchemaParticle sp, XmlCursor xmlc)
+ {
+ int minOccurs = sp.getIntMinOccurs();
+ int maxOccurs = sp.getIntMaxOccurs();
+
+ if (minOccurs == maxOccurs)
+ return minOccurs;
+
+ int result = minOccurs;
+ if (result == 0 && _nElements < MAX_ELEMENTS)
+ result = 1;
+
+ if (sp.getParticleType() != SchemaParticle.ELEMENT)
+ return result;
+
+ // it probably only makes sense to put comments in front of individual elements that repeat
+
+ if (sp.getMaxOccurs() == null)
+ {
+ // xmlc.insertComment("The next " + getItemNameOrType(sp, xmlc) + " may be repeated " + minOccurs + " or more times");
+ if (minOccurs == 0)
+ xmlc.insertComment("Zero or more repetitions:");
+ else
+ xmlc.insertComment(minOccurs + " or more repetitions:");
+ }
+ else if (sp.getIntMaxOccurs() > 1)
+ {
+ xmlc.insertComment(minOccurs + " to " + String.valueOf(sp.getMaxOccurs()) + " repetitions:");
+ }
+ else
+ {
+ xmlc.insertComment("Optional:");
+ }
+ return result;
+ }
+
+ /*
+ Return a name for the element or the particle type to use in the comment for minoccurs, max occurs
+ */
+ private String getItemNameOrType(SchemaParticle sp, XmlCursor xmlc)
+ {
+ String elementOrTypeName = null;
+ if (sp.getParticleType() == SchemaParticle.ELEMENT)
+ {
+ elementOrTypeName = "Element (" + sp.getName().getLocalPart() + ")";
+ }
+ else
+ {
+ elementOrTypeName = printParticleType(sp.getParticleType());
+ }
+ return elementOrTypeName;
+ }
+
+ private void processElement(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
+ {
+ // cast as schema local element
+ SchemaLocalElement element = (SchemaLocalElement) sp;
+ /// ^ -> <elemenname></elem>^
+ if (_soapEnc)
+ xmlc.insertElement(element.getName().getLocalPart()); // soap encoded? drop namespaces.
+ else
+ xmlc.insertElement(element.getName().getLocalPart(), element.getName().getNamespaceURI());
+ _nElements++;
+ /// -> <elem>^</elem>
+ xmlc.toPrevToken();
+ // -> <elem>stuff^</elem>
+ createSampleForType(element.getType(), xmlc);
+ // -> <elem>stuff</elem>^
+ xmlc.toNextToken();
+
+ }
+
+ private void moveToken(int numToMove, XmlCursor xmlc)
+ {
+ for (int i = 0; i < Math.abs(numToMove); i++)
+ {
+ if (numToMove < 0)
+ {
+ xmlc.toPrevToken();
+ }
+ else
+ {
+ xmlc.toNextToken();
+ }
+ }
+ }
+
+ private static final String formatQName(XmlCursor xmlc, QName qName)
+ {
+ XmlCursor parent = xmlc.newCursor();
+ parent.toParent();
+ String prefix = parent.prefixForNamespace(qName.getNamespaceURI());
+ parent.dispose();
+ String name;
+ if (prefix == null || prefix.length() == 0)
+ name = qName.getLocalPart();
+ else
+ name = prefix + ":" + qName.getLocalPart();
+ return name;
+ }
+
+ private static final QName HREF = new QName("href");
+ private static final QName ID = new QName("id");
+ private static final QName XSI_TYPE = new QName("http://www.w3.org/2001/XMLSchema-instance", "type");
+ private static final QName ENC_ARRAYTYPE = new QName("http://schemas.xmlsoap.org/soap/encoding/", "arrayType");
+ private static final QName ENC_OFFSET = new QName("http://schemas.xmlsoap.org/soap/encoding/", "offset");
+
+ private static final Set SKIPPED_SOAP_ATTRS = new HashSet(Arrays.asList(new QName[] { HREF, ID, ENC_OFFSET}));
+ private void processAttributes(SchemaType stype, XmlCursor xmlc)
+ {
+ if (_soapEnc)
+ {
+ QName typeName = stype.getName();
+ if (typeName != null)
+ {
+ xmlc.insertAttributeWithValue(XSI_TYPE, formatQName(xmlc, typeName));
+ }
+ }
+
+ SchemaProperty[] attrProps = stype.getAttributeProperties();
+ for (int i = 0; i < attrProps.length; i++)
+ {
+ SchemaProperty attr = attrProps[i];
+ if (_soapEnc)
+ {
+ if (SKIPPED_SOAP_ATTRS.contains(attr.getName()))
+ continue;
+ if (ENC_ARRAYTYPE.equals(attr.getName()))
+ {
+ SOAPArrayType arrayType = ((SchemaWSDLArrayType)stype.getAttributeModel().getAttribute(attr.getName())).getWSDLArrayType();
+ if (arrayType != null)
+ xmlc.insertAttributeWithValue(attr.getName(), formatQName(xmlc, arrayType.getQName()) + arrayType.soap11DimensionString());
+ continue;
+ }
+ }
+ String defaultValue = attr.getDefaultText();
+ xmlc.insertAttributeWithValue(attr.getName(), defaultValue == null ?
+ sampleDataForSimpleType(attr.getType()) : defaultValue);
+ }
+ }
+
+ private void processSequence(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
+ {
+ SchemaParticle[] spc = sp.getParticleChildren();
+ for (int i=0; i < spc.length; i++)
+ {
+ /// <parent>maybestuff^</parent>
+ processParticle(spc[i], xmlc, mixed);
+ //<parent>maybestuff...morestuff^</parent>
+ if (mixed && i < spc.length-1)
+ {
+ if ( isGenerate_sample_data() )
+ {
+ xmlc.insertChars(pick(WORDS));
+ }
+ else
+ {
+ xmlc.insertChars("");
+ }
+ }
+ }
+ }
+
+ private void processChoice(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
+ {
+ SchemaParticle[] spc = sp.getParticleChildren();
+ xmlc.insertComment("You have a CHOICE of the next " + String.valueOf(spc.length) + " items at this level");
+ for (int i=0; i < spc.length; i++)
+ {
+ processParticle(spc[i], xmlc, mixed);
+ }
+ }
+
+ private void processAll(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
+ {
+ SchemaParticle[] spc = sp.getParticleChildren();
+ // xmlc.insertComment("You may enter the following " + String.valueOf(spc.length) + " items in any order");
+ for (int i=0; i < spc.length; i++)
+ {
+ processParticle(spc[i], xmlc, mixed);
+ if (mixed && i < spc.length-1)
+ xmlc.insertChars(pick(WORDS));
+ }
+ }
+
+ private void processWildCard(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
+ {
+ xmlc.insertComment("You may enter ANY elements at this point");
+ xmlc.insertElement("AnyElement");
+ }
+
+ /**
+ * This method will get the base type for the schema type
+ */
+
+ private static QName getClosestName(SchemaType sType)
+ {
+ while (sType.getName() == null)
+ sType = sType.getBaseType();
+
+ return sType.getName();
+ }
+
+ private String printParticleType(int particleType)
+ {
+ StringBuffer returnParticleType = new StringBuffer();
+ returnParticleType.append("Schema Particle Type: ");
+
+ switch (particleType)
+ {
+ case SchemaParticle.ALL :
+ returnParticleType.append("ALL\n");
+ break;
+ case SchemaParticle.CHOICE :
+ returnParticleType.append("CHOICE\n");
+ break;
+ case SchemaParticle.ELEMENT :
+ returnParticleType.append("ELEMENT\n");
+ break;
+ case SchemaParticle.SEQUENCE :
+ returnParticleType.append("SEQUENCE\n");
+ break;
+ case SchemaParticle.WILDCARD :
+ returnParticleType.append("WILDCARD\n");
+ break;
+ default :
+ returnParticleType.append("Schema Particle Type Unknown");
+ break;
+ }
+
+ return returnParticleType.toString();
+ }
+
+ private ArrayList _typeStack = new ArrayList();
+
+ public boolean isGenerate_sample_data()
+ {
+ return generate_sample_data;
+ }
+
+ public void setGenerate_sample_data(boolean generate_sample_data)
+ {
+ this.generate_sample_data = generate_sample_data;
+ }
+}
diff --git a/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XBbasedXMLGenerator.java b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XBbasedXMLGenerator.java new file mode 100644 index 0000000000..03029bdf43 --- /dev/null +++ b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XBbasedXMLGenerator.java @@ -0,0 +1,239 @@ +package org.apache.tuscany.tools.xmlfromxsd.generate;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.wsdl.Definition;
+import javax.wsdl.WSDLException;
+import javax.wsdl.extensions.schema.Schema;
+import javax.wsdl.factory.WSDLFactory;
+import javax.wsdl.xml.WSDLReader;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.axis2.util.XMLUtils;
+import org.apache.xmlbeans.SchemaType;
+import org.apache.xmlbeans.SchemaTypeSystem;
+import org.apache.xmlbeans.XmlBeans;
+import org.apache.xmlbeans.XmlException;
+import org.apache.xmlbeans.XmlObject;
+import org.apache.xmlbeans.XmlOptions;
+import org.apache.xmlbeans.impl.xsd2inst.SchemaInstanceGenerator;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+import com.ibm.wsdl.util.xml.DOM2Writer;
+
+public class XBbasedXMLGenerator extends SchemaInstanceGenerator implements XMLGenerator
+{
+ private XMLfromXSDConfiguration config = null;
+
+ public XBbasedXMLGenerator(XMLfromXSDConfiguration config)
+ {
+ this.config = config;
+ // config.setXsdInputStream(getClass().getResource(conf).openStream());
+ }
+
+ public void generateXML() throws Exception
+ {
+ SchemaTypeSystem sts = processXSDSources();
+ SchemaType rootElementType = getRootElementSchemaType(sts);
+ if ( rootElementType != null )
+ {
+ TuscanySampleXmlUtil xmlUtil = new TuscanySampleXmlUtil();
+ xmlUtil.setGenerate_sample_data(config.isGenerateSampleData());
+ String result = xmlUtil.createSampleForType(rootElementType);
+ config.getXmlOutputStream().write(result.getBytes());
+ //System.out.println(result);
+ }
+ else
+ {
+ System.out.println("Could not find a global element with name \"" + config.getRootElementLocalName() + "\"");
+ }
+ }
+
+ protected SchemaType getRootElementSchemaType(SchemaTypeSystem sts)
+ {
+ SchemaType schemaType = null;
+
+ if (sts == null)
+ {
+ System.out.println("No Schemas to process.");
+ }
+ else
+ {
+ //first check in the global types
+ SchemaType[] globalTypes = sts.globalTypes();
+ for (int i = 0; i < globalTypes.length; i++)
+ {
+ if (config.getSchemaTypeName().equals(globalTypes[i].getName().getLocalPart()))
+ {
+ schemaType = globalTypes[i];
+ break;
+ }
+ }
+
+ //next check for anonymous types defined inline within elements
+ if ( schemaType == null )
+ {
+ SchemaType[] globalElems = sts.documentTypes();
+ for (int i = 0; i < globalElems.length; i++)
+ {
+ if (config.getSchemaTypeName().equals(globalElems[i].getDocumentElementName().getLocalPart()))
+ {
+ schemaType = globalElems[i];
+ break;
+ }
+ }
+ }
+ }
+ return schemaType;
+ }
+
+ public void generateXML(XMLfromXSDConfiguration config) throws Exception
+ {
+ this.config = config;
+ generateXML();
+ }
+
+ public XMLfromXSDConfiguration getConfig()
+ {
+ return config;
+ }
+
+ public void setConfig(XMLfromXSDConfiguration config)
+ {
+ this.config = config;
+ }
+
+ private Definition readInTheWSDLFile(InputStream wsdlStream) throws WSDLException
+ {
+ WSDLReader reader = WSDLFactory.newInstance().newWSDLReader();
+ reader.setFeature("javax.wsdl.importDocuments", true);
+
+ /*File file = new File(uri);
+ String baseURI;
+
+ if (uri.startsWith("http://")){
+ baseURI = uri;
+ } else{
+ if(file.getParentFile() == null){
+ try {
+ baseURI = new File(".").getCanonicalFile().toURI().toString();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ } else {
+ baseURI = file.getParentFile().toURI().toString();
+ }
+ }
+*/
+ Document doc;
+ try {
+ doc = XMLUtils.newDocument(wsdlStream);
+ } catch (ParserConfigurationException e) {
+ throw new WSDLException(WSDLException.PARSER_ERROR,
+ "Parser Configuration Error",
+ e);
+ } catch (SAXException e) {
+ throw new WSDLException(WSDLException.PARSER_ERROR,
+ "Parser SAX Error",
+ e);
+
+ } catch (IOException e) {
+ throw new WSDLException(WSDLException.INVALID_WSDL, "IO Error", e);
+ }
+
+ return reader.readWSDL(config.getRootElementNamespaceURI(), doc);
+ }
+
+ protected InputStream[] getXSDsFromWSDL(InputStream xsdInputStream) throws Exception
+ {
+ Definition defn = readInTheWSDLFile(xsdInputStream);
+ List list = defn.getTypes().getExtensibilityElements();
+
+ InputStream[] xsdFragments = new InputStream[list.size()];
+
+ Iterator iterator = list.iterator();
+ Schema schemaElement = null;
+
+ for ( int count = 0 ; count < list.size() ; ++count )
+ {
+ schemaElement = (Schema)iterator.next();
+ //System.out.println(" *** - " + element.getElementType().getNamespaceURI());
+ //System.out.println(" **** - " + element + " & " + element.getClass().getPackage().getName());
+ //System.out.println(DOM2Writer.nodeToString(element.getElement()));
+ xsdFragments[count] =
+ new ByteArrayInputStream(DOM2Writer.nodeToString(schemaElement.getElement()).getBytes());
+ }
+
+ return xsdFragments;
+ }
+
+ protected SchemaTypeSystem processXSDSources() throws Exception
+ {
+ SchemaTypeSystem sts = null;
+ if ( config.getXsdFileName().endsWith(XSD_FILE) )
+ {
+ sts = processXSDs(new InputStream[]{ config.getXsdInputStream()} );
+ }
+ else if ( config.getXsdFileName().endsWith(WSDL_FILE) )
+ {
+ sts = processXSDs(getXSDsFromWSDL(config.getXsdInputStream()));
+ }
+ return sts;
+ }
+
+ protected SchemaTypeSystem processXSDs(InputStream[] inputStreams)
+ {
+ List sdocs = new ArrayList();
+ for (int i = 0; i < inputStreams.length; i++)
+ {
+ try
+ {
+ sdocs.add(XmlObject.Factory.parse(inputStreams[i],
+ (new XmlOptions()).setLoadLineNumbers().setLoadMessageDigest()));
+ }
+ catch (Exception e)
+ {
+ System.err.println("Can not load schema file: " + inputStreams[i] + ": ");
+ e.printStackTrace();
+ }
+ }
+
+ XmlObject[] schemas = (XmlObject[]) sdocs.toArray(new XmlObject[sdocs.size()]);
+
+ SchemaTypeSystem sts = null;
+ if (schemas.length > 0)
+ {
+ Collection errors = new ArrayList();
+ XmlOptions compileOptions = new XmlOptions();
+ /*if (dl)
+ compileOptions.setCompileDownloadUrls();
+ if (nopvr)
+ compileOptions.setCompileNoPvrRule();
+ if (noupa)
+ compileOptions.setCompileNoUpaRule();
+ */
+ try
+ {
+ sts = XmlBeans.compileXsd(schemas, XmlBeans.getBuiltinTypeSystem(), compileOptions);
+ }
+ catch (Exception e)
+ {
+ if (errors.isEmpty() || !(e instanceof XmlException))
+ e.printStackTrace();
+
+ System.out.println("Schema compilation errors: ");
+ for (Iterator i = errors.iterator(); i.hasNext(); )
+ System.out.println(i.next());
+ }
+ }
+
+ return sts;
+ }
+}
diff --git a/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLGenerator.java b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLGenerator.java new file mode 100644 index 0000000000..4c54e64cb5 --- /dev/null +++ b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLGenerator.java @@ -0,0 +1,35 @@ +/**
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors as applicable
+ *
+ * Licensed 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.tuscany.tools.xmlfromxsd.generate;
+/**
+ * This is the XMLGenerator Interface that will be implemented by various
+ * types of Generators (SDO based, XMLBeans based etc.)
+ *
+ */
+public interface XMLGenerator
+{
+ public static final int SDO_BASED = 1;
+ public static final int XMLBEANS_BASED = 2;
+
+ public static final String XSD_FILE = ".xsd";
+ public static final String WSDL_FILE = ".wsdl";
+
+ public void generateXML() throws Exception;
+ public void generateXML(XMLfromXSDConfiguration config) throws Exception;
+ public XMLfromXSDConfiguration getConfig();
+ public void setConfig(XMLfromXSDConfiguration config);
+}
diff --git a/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLGeneratorFactory.java b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLGeneratorFactory.java new file mode 100644 index 0000000000..d669374b0e --- /dev/null +++ b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLGeneratorFactory.java @@ -0,0 +1,61 @@ +/**
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors as applicable
+ *
+ * Licensed 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.tuscany.tools.xmlfromxsd.generate;
+
+/**
+ * This is a factory for creating XML Generators. The types of XML Generators
+ * are enumerated in the XMLGenerator interface.
+ *
+ */
+public class XMLGeneratorFactory
+{
+ private static XMLGeneratorFactory factory = null;
+
+ protected XMLGeneratorFactory()
+ {
+
+ }
+
+ public static XMLGeneratorFactory getInstance()
+ {
+ if ( factory == null )
+ {
+ factory = new XMLGeneratorFactory();
+ }
+ return factory;
+ }
+
+ public XMLGenerator createGenerator(int generatorType)
+ {
+ XMLGenerator generator = null;
+ switch ( generatorType )
+ {
+ case XMLGenerator.SDO_BASED :
+ {
+ generator = new SDObasedXMLGenerator(new XMLfromXSDConfiguration());
+ break;
+ }
+ case XMLGenerator.XMLBEANS_BASED :
+ {
+ generator = new XBbasedXMLGenerator(new XMLfromXSDConfiguration());
+ break;
+ }
+ }
+
+ return generator;
+ }
+}
diff --git a/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLfromXSDConfiguration.java b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLfromXSDConfiguration.java new file mode 100644 index 0000000000..bd3d8bc403 --- /dev/null +++ b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLfromXSDConfiguration.java @@ -0,0 +1,284 @@ +/**
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors as applicable
+ *
+ * Licensed 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.tuscany.tools.xmlfromxsd.generate;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URL;
+
+import org.apache.ws.java2wsdl.Java2WSDLUtils;
+
+/**
+ * This class encapsulates the configuration settings for the "XML From XSD" generation.
+ * Presently it contains settings like the XSD to be use, the schematype for which and
+ * xml instance is to be created, the destination for the output etc. All of these
+ * settings are used by the 'generator' classes during the genation of the xml instance.
+ *
+ */
+public class XMLfromXSDConfiguration implements CmdLineArgsHandler
+{
+ private static int fileCount = 0;
+ public static final String DEFAULT_XML_OUTPUT_FILENAME = "XML_FROM_XSD_" + (++fileCount) + ".xml";
+
+ public static final String XSD_FILE_URL_OPTION = "xsd";
+ public static final String XML_OUTPUT_LOCATION_OPTION = "o";
+ public static final String XML_OUTPUT_FILENAME_OPTION = "of";
+ public static final String ROOT_ELEMENT_NAMESPACE_URI_OPTION = "rns";
+ public static final String ROOT_ELEMENT_LOCALNAME_OPTION = "rn";
+ public static final String SCHEMA_TYPE_NAME = "st";
+ public static final String SCHEMA_TYPE_NAMESPACE_URI = "stn";
+ public static final String GENERATE_SAMPLE_DATA = "sd";
+
+ protected String xmlOutputLocation = null;
+ protected File xmlOutputDirectory = null;
+ protected String xsdFileName = null;
+ protected String xmlFileName = null;
+ protected InputStream xsdInputStream = null;
+ protected OutputStream xmlOutputStream = null;
+ protected String rootElementNamespaceURI = null;
+ protected String rootElementLocalName = null;
+ protected String schemaTypeName = null;
+ protected String schemaTypeNamespaceURI = null;
+ protected boolean generateSampleData = false;
+
+ private void handleXSDInputFileOption(String xsdFileUrl) throws Exception
+ {
+ xsdFileName = xsdFileUrl;
+ //xsdInputStream = new FileInputStream(new File(xsdFileName));
+ URL resourceUrl = Thread.currentThread().getContextClassLoader().getResource(xsdFileName);
+ if ( resourceUrl != null )
+ {
+ xsdInputStream = resourceUrl.openStream();
+ }
+ else
+ {
+ File inFile = new File(xsdFileName);
+ xsdFileName = inFile.getName();
+ xsdInputStream = new FileInputStream(inFile);
+ }
+ }
+
+ private void handleXMLOutputLocationOption(String outputLocation) throws Exception
+ {
+ xmlOutputLocation = outputLocation;
+ xmlOutputDirectory = new File(xmlOutputLocation);
+ if (!xmlOutputDirectory.exists())
+ {
+ xmlOutputDirectory.mkdirs();
+ }
+ else if (!xmlOutputDirectory.isDirectory())
+ {
+ throw new IllegalArgumentException("The input location for the xml output " + outputLocation + "is not a folder");
+ }
+ }
+
+ private void handleOutputFilenameOption(String outputFileName) throws Exception
+ {
+ xmlFileName = outputFileName;
+
+ //first create a file in the given location
+ File outputFile = new File(xmlOutputDirectory, xmlFileName);
+
+ try {
+ if (!outputFile.exists()) {
+ outputFile.createNewFile();
+ }
+ xmlOutputStream = new FileOutputStream(outputFile);
+ } catch (IOException e) {
+ throw new Exception(e);
+ }
+ }
+
+ public void handleArgument(String optionFlag, String argValue) throws IllegalArgumentException
+ {
+ try
+ {
+ if ( XSD_FILE_URL_OPTION.equalsIgnoreCase(optionFlag) )
+ {
+ handleXSDInputFileOption(argValue);
+ }
+ else if ( XML_OUTPUT_LOCATION_OPTION.equalsIgnoreCase(optionFlag) )
+ {
+ handleXMLOutputLocationOption(argValue);
+ }
+ else if ( XML_OUTPUT_FILENAME_OPTION.equalsIgnoreCase(optionFlag) )
+ {
+ handleOutputFilenameOption(argValue);
+ }
+ else if ( ROOT_ELEMENT_NAMESPACE_URI_OPTION.equalsIgnoreCase(optionFlag) )
+ {
+ setRootElementNamespaceURI(argValue);
+ }
+ else if ( ROOT_ELEMENT_LOCALNAME_OPTION.equalsIgnoreCase(optionFlag) )
+ {
+ setRootElementLocalName(argValue);
+ }
+ else if ( SCHEMA_TYPE_NAME.equalsIgnoreCase(optionFlag) )
+ {
+ setSchemaTypeName(argValue);
+ }
+ else if ( SCHEMA_TYPE_NAMESPACE_URI.equalsIgnoreCase(optionFlag) )
+ {
+ setSchemaTypeNamespaceURI(argValue);
+ }
+ else if ( GENERATE_SAMPLE_DATA.equalsIgnoreCase(optionFlag) )
+ {
+ setGenerateSampleData(true);
+ }
+ }
+ catch ( Exception e )
+ {
+ throw new IllegalArgumentException("Exception due to - " + e);
+ }
+ }
+
+ public String getRootElementLocalName()
+ {
+ if ( rootElementLocalName == null )
+ {
+ rootElementLocalName = schemaTypeName.toLowerCase();
+ }
+ return rootElementLocalName;
+ }
+
+ public void setRootElementLocalName(String rootElementLocalName)
+ {
+ this.rootElementLocalName = rootElementLocalName;
+ }
+
+ public String getRootElementNamespaceURI()
+ {
+ if ( rootElementNamespaceURI == null )
+ {
+ rootElementNamespaceURI = schemaTypeNamespaceURI;
+ }
+ return rootElementNamespaceURI;
+ }
+
+ public void setRootElementNamespaceURI(String rootElementNamespaceURI)
+ {
+ this.rootElementNamespaceURI = rootElementNamespaceURI;
+ }
+
+ public String getXmlFileName()
+ {
+ if ( xmlFileName == null )
+ {
+ xmlFileName = getXsdFileName() + ".xml";
+ }
+ return xmlFileName;
+ }
+
+ public void setXmlFileName(String xmlFileName)
+ {
+ this.xmlFileName = xmlFileName;
+ }
+
+ public File getXmlOutputLocation()
+ {
+ return xmlOutputDirectory;
+ }
+
+ public void setXmlOutputLocation(File xmlOutputLocation)
+ {
+ this.xmlOutputDirectory = xmlOutputLocation;
+ }
+
+ public OutputStream getXmlOutputStream() throws Exception
+ {
+ if ( xmlOutputStream == null )
+ {
+ if ( xmlOutputDirectory == null )
+ {
+ handleXMLOutputLocationOption(System.getProperty("user.dir"));
+ }
+ handleOutputFilenameOption(getXmlFileName());
+ }
+ return xmlOutputStream;
+ }
+
+ public void setXmlOutputStream(OutputStream xmlOutputStream)
+ {
+ this.xmlOutputStream = xmlOutputStream;
+ }
+
+ public String getXsdFileName()
+ {
+ return xsdFileName;
+ }
+
+ public void setXsdFileName(String xsdFileName) throws Exception
+ {
+ this.xsdFileName = xsdFileName;
+ handleXSDInputFileOption(xsdFileName);
+ }
+
+ public InputStream getXsdInputStream() throws Exception
+ {
+ if ( xsdInputStream == null )
+ {
+ throw new IllegalArgumentException("XSD Input Source not set....!");
+ }
+ return xsdInputStream;
+ }
+
+ public void setXsdInputStream(InputStream xsdInputStream)
+ {
+ this.xsdInputStream = xsdInputStream;
+ }
+
+ public String getSchemaTypeName()
+ {
+ return schemaTypeName;
+ }
+
+ public void setSchemaTypeName(String schemaTypeName)
+ {
+ this.schemaTypeName = schemaTypeName;
+ }
+
+ public String getSchemaTypeNamespaceURI()
+ {
+ return schemaTypeNamespaceURI;
+ }
+
+ public void setSchemaTypeNamespaceURI(String schemaTypeNamespaceURI)
+ {
+ this.schemaTypeNamespaceURI = schemaTypeNamespaceURI;
+ }
+
+ public void setXmlOutputLocation(String xmlOutputLocation) throws Exception
+ {
+ this.xmlOutputLocation = xmlOutputLocation;
+ handleXMLOutputLocationOption(xmlOutputLocation);
+ }
+
+ public boolean isGenerateSampleData()
+ {
+ return generateSampleData;
+ }
+
+ public void setGenerateSampleData(boolean generateSampleData)
+ {
+ this.generateSampleData = generateSampleData;
+ }
+
+}
diff --git a/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLfromXSDGenerator.java b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLfromXSDGenerator.java new file mode 100644 index 0000000000..e464c56d01 --- /dev/null +++ b/sandbox/tools/xmlfromxsd/src/main/java/org/apache/tuscany/tools/xmlfromxsd/generate/XMLfromXSDGenerator.java @@ -0,0 +1,87 @@ +/**
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors as applicable
+ *
+ * Licensed 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.tuscany.tools.xmlfromxsd.generate;
+
+/**
+ * This class provides a command line tooling functinality for creating an
+ * XML instance from an input XSD.
+ *
+ */
+public class XMLfromXSDGenerator
+{
+ public static int generatorType = XMLGenerator.SDO_BASED;
+ /**
+ * @param args
+ */
+ public static void main(String[] args)
+ {
+ try
+ {
+ new XMLfromXSDGenerator().generateXMLInstance(args);
+ }
+ catch ( Exception e )
+ {
+ e.printStackTrace();
+ System.out.println(getPrintUsageMessage());
+ }
+ }
+
+ public void generateXMLInstance(String args[]) throws Exception
+ {
+ //create a configuration object to hold settings for this generation
+ XMLfromXSDConfiguration config = new XMLfromXSDConfiguration();
+
+ //create an argument processor to process the input arguments
+ CmdLineArgsProcessor argsProcessor = new CmdLineArgsProcessor();
+
+ //configure the args processor with the 'config' object that must be populated
+ //with values from the proecessed input arguments
+ argsProcessor.setArgsHandler(config);
+
+ //set the usage message to be output by the args processor if input arguments are not proper
+ argsProcessor.setPrintUsageMessage(getPrintUsageMessage());
+
+ //start processing the arguments
+ argsProcessor.processArgs(args);
+
+ //now that the configuration settings are populated from the input arguments
+ //instantiate the xmlfromsdogenerator with this config object
+
+ XMLGenerator generator = new XMLGeneratorFactory().createGenerator(generatorType);
+ //XBbasedXMLGenerator generator = new XBbasedXMLGenerator(config);
+
+ //generate the xml instance
+ generator.generateXML(config);
+ }
+
+ protected static String getPrintUsageMessage()
+ {
+ StringBuffer strBuffer = new StringBuffer();
+ strBuffer.append("Usage arguments:\n");
+ strBuffer.append(" [ -rns <root element namespace URI> ]\n");
+ strBuffer.append(" [ -rn <root element name> ]\n");
+ strBuffer.append(" [ -xsd <xsd file> ]\n");
+ strBuffer.append(" [ -of <output xml filename> ]\n");
+ strBuffer.append(" [ -o <output location> ]\n");
+ strBuffer.append(" [ -st <name of the schema type to be instantiated as xml> ]\n");
+ strBuffer.append(" [ -stn <namespace URI of the schema type> ]\n");
+ strBuffer.append(" [ -sd (provide this flag if sample data is to be generated)\n");
+
+ return strBuffer.toString();
+ }
+
+}
|