Home » xmlbeans-2.5.0-src » org.apache.xmlbeans.impl » xsd2inst » [javadoc | source]

    1   /*   Copyright 2004 The Apache Software Foundation
    2    *
    3    *   Licensed under the Apache License, Version 2.0 (the "License");
    4    *   you may not use this file except in compliance with the License.
    5    *   You may obtain a copy of the License at
    6    *
    7    *       http://www.apache.org/licenses/LICENSE-2.0
    8    *
    9    *   Unless required by applicable law or agreed to in writing, software
   10    *   distributed under the License is distributed on an "AS IS" BASIS,
   11    *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12    *   See the License for the specific language governing permissions and
   13    *  limitations under the License.
   14    */
   15   
   16   package org.apache.xmlbeans.impl.xsd2inst;
   17   
   18   /*
   19    * TODO:
   20   *  Comment on enumerations?
   21   *  Comment on facets?
   22   *  Have a verbose option?
   23   *  Have a sample data option, would create valid instance with sample data?
   24   *  Add the pattern facet; this is tricky, considering the relationship with length
   25   */
   26   
   27   import org.apache.xmlbeans.SchemaType;
   28   import org.apache.xmlbeans.XmlCursor;
   29   import org.apache.xmlbeans.SchemaParticle;
   30   import org.apache.xmlbeans.SchemaLocalElement;
   31   import org.apache.xmlbeans.SchemaProperty;
   32   import org.apache.xmlbeans.GDuration;
   33   import org.apache.xmlbeans.GDurationBuilder;
   34   import org.apache.xmlbeans.GDate;
   35   import org.apache.xmlbeans.GDateBuilder;
   36   import org.apache.xmlbeans.XmlAnySimpleType;
   37   import org.apache.xmlbeans.SimpleValue;
   38   import org.apache.xmlbeans.XmlOptions;
   39   import org.apache.xmlbeans.XmlObject;
   40   import org.apache.xmlbeans.XmlInteger;
   41   import org.apache.xmlbeans.XmlDate;
   42   import org.apache.xmlbeans.XmlDateTime;
   43   import org.apache.xmlbeans.XmlTime;
   44   import org.apache.xmlbeans.XmlGYear;
   45   import org.apache.xmlbeans.XmlGYearMonth;
   46   import org.apache.xmlbeans.XmlGMonth;
   47   import org.apache.xmlbeans.XmlGMonthDay;
   48   import org.apache.xmlbeans.XmlGDay;
   49   import org.apache.xmlbeans.XmlDecimal;
   50   import org.apache.xmlbeans.XmlDuration;
   51   import org.apache.xmlbeans.soap.SchemaWSDLArrayType;
   52   import org.apache.xmlbeans.soap.SOAPArrayType;
   53   import org.apache.xmlbeans.impl.util.Base64;
   54   import org.apache.xmlbeans.impl.util.HexBin;
   55   
   56   import java.math.BigDecimal;
   57   import java.math.BigInteger;
   58   import java.util.ArrayList;
   59   import java.util.Calendar;
   60   import java.util.Date;
   61   import java.util.Random;
   62   import java.util.Set;
   63   import java.util.HashSet;
   64   import java.util.Arrays;
   65   
   66   import javax.xml.namespace.QName;
   67   
   68   public class SampleXmlUtil
   69   {
   70       private boolean _soapEnc;
   71       private static final int MAX_ELEMENTS = 1000;
   72       private int _nElements;
   73   
   74       private SampleXmlUtil(boolean soapEnc)
   75       {
   76           _soapEnc = soapEnc;
   77       }
   78   
   79       public static String createSampleForType(SchemaType sType)
   80       {
   81           XmlObject object = XmlObject.Factory.newInstance();
   82           XmlCursor cursor = object.newCursor();
   83           // Skip the document node
   84           cursor.toNextToken();
   85           // Using the type and the cursor, call the utility method to get a
   86           // sample XML payload for that Schema element
   87           new SampleXmlUtil(false).createSampleForType(sType, cursor);
   88           // Cursor now contains the sample payload
   89           // Pretty print the result.  Note that the cursor is positioned at the
   90           // end of the doc so we use the original xml object that the cursor was
   91           // created upon to do the xmlText() against.
   92           XmlOptions options = new XmlOptions();
   93           options.put(XmlOptions.SAVE_PRETTY_PRINT);
   94           options.put(XmlOptions.SAVE_PRETTY_PRINT_INDENT, 2);
   95           options.put(XmlOptions.SAVE_AGGRESSIVE_NAMESPACES);
   96           String result = object.xmlText(options);
   97           return result;
   98       }
   99   
  100       Random _picker = new Random(1);
  101   
  102       /**
  103        * Cursor position
  104        * Before:
  105        * <theElement>^</theElement>
  106        * After:
  107        * <theElement><lots of stuff/>^</theElement>
  108        */
  109       private void createSampleForType(SchemaType stype, XmlCursor xmlc)
  110       {
  111           if (_typeStack.contains( stype ))
  112               return;
  113   
  114           _typeStack.add( stype );
  115           
  116           try
  117           {
  118               if (stype.isSimpleType() || stype.isURType())
  119               {
  120                   processSimpleType(stype, xmlc);
  121                   return;
  122               }
  123               
  124               // complex Type
  125               // <theElement>^</theElement>
  126               processAttributes(stype, xmlc);
  127               
  128               // <theElement attri1="string">^</theElement>
  129               switch (stype.getContentType())
  130               {
  131                   case SchemaType.NOT_COMPLEX_TYPE :
  132                   case SchemaType.EMPTY_CONTENT :
  133                       // noop
  134                       break;
  135                   case SchemaType.SIMPLE_CONTENT :
  136                       {
  137                           processSimpleType(stype, xmlc);
  138                       }
  139                       break;
  140                   case SchemaType.MIXED_CONTENT :
  141                       xmlc.insertChars(pick(WORDS) + " ");
  142                       if (stype.getContentModel() != null)
  143                       {
  144                           processParticle(stype.getContentModel(), xmlc, true);
  145                       }
  146                       xmlc.insertChars(pick(WORDS));
  147                       break;
  148                   case SchemaType.ELEMENT_CONTENT :
  149                       if (stype.getContentModel() != null)
  150                       {
  151                           processParticle(stype.getContentModel(), xmlc, false);
  152                       }
  153                       break;
  154               }
  155           }
  156           finally
  157           {
  158               _typeStack.remove( _typeStack.size() - 1 );
  159           }
  160       }
  161   
  162       private void processSimpleType(SchemaType stype, XmlCursor xmlc)
  163       {
  164           String sample = sampleDataForSimpleType(stype);
  165           xmlc.insertChars(sample);
  166       }
  167       
  168       private String sampleDataForSimpleType(SchemaType sType)
  169       {
  170           if (XmlObject.type.equals(sType))
  171               return "anyType";
  172           
  173           if (XmlAnySimpleType.type.equals(sType))
  174               return "anySimpleType";
  175           
  176           if (sType.getSimpleVariety() == SchemaType.LIST)
  177           {
  178               SchemaType itemType = sType.getListItemType();
  179               StringBuffer sb = new StringBuffer();
  180               int length = pickLength(sType);
  181               if (length > 0)
  182                   sb.append(sampleDataForSimpleType(itemType));
  183               for (int i = 1; i < length; i += 1)
  184               {
  185                   sb.append(' ');
  186                   sb.append(sampleDataForSimpleType(itemType));
  187               }
  188               return sb.toString(); 
  189           }
  190           
  191           if (sType.getSimpleVariety() == SchemaType.UNION)
  192           {
  193               SchemaType[] possibleTypes = sType.getUnionConstituentTypes();
  194               if (possibleTypes.length == 0)
  195                   return "";
  196               return sampleDataForSimpleType(possibleTypes[pick(possibleTypes.length)]);
  197           }
  198           
  199           XmlAnySimpleType[] enumValues = sType.getEnumerationValues();
  200           if (enumValues != null && enumValues.length > 0)
  201           {
  202               return enumValues[pick(enumValues.length)].getStringValue();
  203           }
  204           
  205           switch (sType.getPrimitiveType().getBuiltinTypeCode())
  206           {
  207               default:
  208               case SchemaType.BTC_NOT_BUILTIN:
  209                   return "";
  210               
  211               case SchemaType.BTC_ANY_TYPE:
  212               case SchemaType.BTC_ANY_SIMPLE:
  213                   return "anything";
  214                   
  215               case SchemaType.BTC_BOOLEAN:
  216                   return pick(2) == 0 ? "true" : "false";
  217                   
  218               case SchemaType.BTC_BASE_64_BINARY:
  219               {
  220                   String result = null;
  221                   try
  222                   {   result = new String(Base64.encode(formatToLength(pick(WORDS), sType).getBytes("utf-8"))); }
  223                   catch (java.io.UnsupportedEncodingException e)
  224                   {  /* Can't possibly happen */ }
  225                   return result;
  226               }
  227                   
  228               case SchemaType.BTC_HEX_BINARY:
  229                   return HexBin.encode(formatToLength(pick(WORDS), sType));
  230                   
  231               case SchemaType.BTC_ANY_URI:
  232                   return formatToLength("http://www." + pick(DNS1) + "." + pick(DNS2) + "/" + pick(WORDS) + "/" + pick(WORDS), sType);
  233                   
  234               case SchemaType.BTC_QNAME:
  235                   return formatToLength("qname", sType);
  236                   
  237               case SchemaType.BTC_NOTATION:
  238                   return formatToLength("notation", sType);
  239                   
  240               case SchemaType.BTC_FLOAT:
  241                   return "1.5E2";
  242               case SchemaType.BTC_DOUBLE:
  243                   return "1.051732E7";
  244               case SchemaType.BTC_DECIMAL:
  245                   switch (closestBuiltin(sType).getBuiltinTypeCode())
  246                   {
  247                       case SchemaType.BTC_SHORT:
  248                           return formatDecimal("1", sType);
  249                       case SchemaType.BTC_UNSIGNED_SHORT:
  250                           return formatDecimal("5", sType);
  251                       case SchemaType.BTC_BYTE:
  252                           return formatDecimal("2", sType);
  253                       case SchemaType.BTC_UNSIGNED_BYTE:
  254                           return formatDecimal("6", sType);
  255                       case SchemaType.BTC_INT:
  256                           return formatDecimal("3", sType);
  257                       case SchemaType.BTC_UNSIGNED_INT:
  258                           return formatDecimal("7", sType);
  259                       case SchemaType.BTC_LONG:
  260                           return formatDecimal("10", sType);
  261                       case SchemaType.BTC_UNSIGNED_LONG:
  262                           return formatDecimal("11", sType);
  263                       case SchemaType.BTC_INTEGER:
  264                           return formatDecimal("100", sType);
  265                       case SchemaType.BTC_NON_POSITIVE_INTEGER:
  266                           return formatDecimal("-200", sType);
  267                       case SchemaType.BTC_NEGATIVE_INTEGER:
  268                           return formatDecimal("-201", sType);
  269                       case SchemaType.BTC_NON_NEGATIVE_INTEGER:
  270                           return formatDecimal("200", sType);
  271                       case SchemaType.BTC_POSITIVE_INTEGER:
  272                           return formatDecimal("201", sType);
  273                       default:
  274                       case SchemaType.BTC_DECIMAL:
  275                           return formatDecimal("1000.00", sType);
  276                   }
  277                   
  278               case SchemaType.BTC_STRING:
  279                   {
  280                       String result;
  281                       switch (closestBuiltin(sType).getBuiltinTypeCode())
  282                       {
  283                           case SchemaType.BTC_STRING:
  284                           case SchemaType.BTC_NORMALIZED_STRING:
  285                               result = "string";
  286                               break;
  287                               
  288                           case SchemaType.BTC_TOKEN:
  289                               result = "token";
  290                               break;
  291                               
  292                           default:
  293                               result = "string";
  294                               break;
  295                       }
  296                           
  297                       return formatToLength(result, sType);
  298                   }
  299   
  300               case SchemaType.BTC_DURATION:
  301                   return formatDuration(sType);
  302                   
  303               case SchemaType.BTC_DATE_TIME:
  304               case SchemaType.BTC_TIME:
  305               case SchemaType.BTC_DATE:
  306               case SchemaType.BTC_G_YEAR_MONTH:
  307               case SchemaType.BTC_G_YEAR:
  308               case SchemaType.BTC_G_MONTH_DAY:
  309               case SchemaType.BTC_G_DAY:
  310               case SchemaType.BTC_G_MONTH:
  311                   return formatDate(sType);
  312           }
  313       }
  314       
  315       // a bit from the Aenid
  316       public static final String[] WORDS = new String[]
  317       {
  318       "ipsa", "iovis", "rapidum", "iaculata", "e", "nubibus", "ignem",
  319       "disiecitque", "rates", "evertitque", "aequora", "ventis",
  320       "illum", "exspirantem", "transfixo", "pectore", "flammas",
  321       "turbine", "corripuit", "scopuloque", "infixit", "acuto",
  322       "ast", "ego", "quae", "divum", "incedo", "regina", "iovisque",
  323       "et", "soror", "et", "coniunx", "una", "cum", "gente", "tot", "annos",
  324       "bella", "gero", "et", "quisquam", "numen", "iunonis", "adorat",
  325       "praeterea", "aut", "supplex", "aris", "imponet", "honorem",
  326       "talia", "flammato", "secum", "dea", "corde", "volutans",
  327       "nimborum", "in", "patriam", "loca", "feta", "furentibus", "austris",
  328       "aeoliam", "venit", "hic", "vasto", "rex", "aeolus", "antro",
  329       "luctantis", "ventos", "tempestatesque", "sonoras",
  330       "imperio", "premit", "ac", "vinclis", "et", "carcere", "frenat",
  331       "illi", "indignantes", "magno", "cum", "murmure", "montis",
  332       "circum", "claustra", "fremunt", "celsa", "sedet", "aeolus", "arce",
  333       "sceptra", "tenens", "mollitque", "animos", "et", "temperat", "iras",
  334       "ni", "faciat", "maria", "ac", "terras", "caelumque", "profundum",
  335       "quippe", "ferant", "rapidi", "secum", "verrantque", "per", "auras",
  336       "sed", "pater", "omnipotens", "speluncis", "abdidit", "atris",
  337       "hoc", "metuens", "molemque", "et", "montis", "insuper", "altos",
  338       "imposuit", "regemque", "dedit", "qui", "foedere", "certo",
  339       "et", "premere", "et", "laxas", "sciret", "dare", "iussus", "habenas",
  340       };
  341       
  342       
  343       
  344       private static final String[] DNS1 = new String[] { "corp", "your", "my", "sample", "company", "test", "any" };
  345       private static final String[] DNS2 = new String[] { "com", "org", "com", "gov", "org", "com", "org", "com", "edu" };
  346                                                          
  347       private int pick(int n)
  348       {
  349           return _picker.nextInt(n);
  350       }
  351       
  352       private String pick(String[] a)
  353       {
  354           return a[pick(a.length)];
  355       }
  356       
  357       private String pick(String[] a, int count)
  358       {
  359           if (count <= 0)
  360               return "";
  361               
  362           int i = pick(a.length);
  363           StringBuffer sb = new StringBuffer(a[i]);
  364           while (count-- > 0)
  365           {
  366               i += 1;
  367               if (i >= a.length)
  368                   i = 0;
  369               sb.append(' ');
  370               sb.append(a[i]);
  371           }
  372           return sb.toString();
  373       }
  374       
  375       private String pickDigits(int digits)
  376       {
  377           StringBuffer sb = new StringBuffer();
  378           while (digits-- > 0)
  379               sb.append(Integer.toString(pick(10)));
  380           return sb.toString();
  381       }
  382   
  383       private int pickLength(SchemaType sType)
  384       {
  385           XmlInteger length = (XmlInteger) sType.getFacet(SchemaType.FACET_LENGTH);
  386           if (length != null)
  387               return length.getBigIntegerValue().intValue();
  388           XmlInteger min    = (XmlInteger) sType.getFacet(SchemaType.FACET_MIN_LENGTH);
  389           XmlInteger max    = (XmlInteger) sType.getFacet(SchemaType.FACET_MAX_LENGTH);
  390           int minInt, maxInt;
  391           if (min == null)
  392               minInt = 0;
  393           else
  394               minInt = min.getBigIntegerValue().intValue();
  395           if (max == null)
  396               maxInt = Integer.MAX_VALUE;
  397           else
  398               maxInt = max.getBigIntegerValue().intValue();
  399           // We try to keep the length of the array within reasonable limits,
  400           // at least 1 item and at most 3 if possible
  401           if (minInt == 0 && maxInt >= 1)
  402               minInt = 1;
  403           if (maxInt > minInt + 2)
  404               maxInt = minInt + 2;
  405           if (maxInt < minInt)
  406               maxInt = minInt;
  407           return minInt + pick(maxInt-minInt);
  408       }
  409   
  410       /**
  411        * Formats a given string to the required length, using the following operations:
  412        * - append the source string to itself as necessary to pass the minLength;
  413        * - truncate the result of previous step, if necessary, to keep it within minLength.
  414        */
  415       private String formatToLength(String s, SchemaType sType)
  416       {
  417           String result = s;
  418           try
  419           {
  420               SimpleValue min = (SimpleValue)sType.getFacet(SchemaType.FACET_LENGTH);
  421               if (min == null)
  422                   min = (SimpleValue)sType.getFacet(SchemaType.FACET_MIN_LENGTH);
  423               if (min != null)
  424               {
  425                   int len = min.getIntValue();
  426                   while (result.length() < len)
  427                       result = result + result;
  428               }
  429               SimpleValue max = (SimpleValue)sType.getFacet(SchemaType.FACET_LENGTH);
  430               if (max == null)
  431                   max = (SimpleValue)sType.getFacet(SchemaType.FACET_MAX_LENGTH);
  432               if (max != null)
  433               {
  434                   int len = max.getIntValue();
  435                   if (result.length() > len)
  436                       result = result.substring(0, len);
  437               }
  438           }
  439           catch (Exception e) // intValue can be out of range
  440           {
  441           }
  442           return result;
  443       }
  444   
  445       private String formatDecimal(String start, SchemaType sType)
  446       {
  447           BigDecimal result = new BigDecimal(start);
  448           XmlDecimal xmlD;
  449           xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  450           BigDecimal min = xmlD != null ? xmlD.getBigDecimalValue() : null;
  451           xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  452           BigDecimal max = xmlD != null ? xmlD.getBigDecimalValue() : null;
  453           boolean minInclusive = true, maxInclusive = true;
  454           xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  455           if (xmlD != null)
  456           {
  457               BigDecimal minExcl = xmlD.getBigDecimalValue();
  458               if (min == null || min.compareTo(minExcl) < 0)
  459               {
  460                   min = minExcl;
  461                   minInclusive = false;
  462               }
  463           }
  464           xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  465           if (xmlD != null)
  466           {
  467               BigDecimal maxExcl = xmlD.getBigDecimalValue();
  468               if (max == null || max.compareTo(maxExcl) > 0)
  469               {
  470                   max = maxExcl;
  471                   maxInclusive = false;
  472               }
  473           }
  474           xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_TOTAL_DIGITS);
  475           int totalDigits = -1;
  476           if (xmlD != null)
  477           {
  478               totalDigits = xmlD.getBigDecimalValue().intValue();
  479   
  480               StringBuffer sb = new StringBuffer(totalDigits);
  481               for (int i = 0; i < totalDigits; i++)
  482                   sb.append('9');
  483               BigDecimal digitsLimit = new BigDecimal(sb.toString());
  484               if (max != null && max.compareTo(digitsLimit) > 0)
  485               {
  486                   max = digitsLimit;
  487                   maxInclusive = true;
  488               }
  489               digitsLimit = digitsLimit.negate();
  490               if (min != null && min.compareTo(digitsLimit) < 0)
  491               {
  492                   min = digitsLimit;
  493                   minInclusive = true;
  494               }
  495           }
  496   
  497           int sigMin = min == null ? 1 : result.compareTo(min);
  498           int sigMax = max == null ? -1 : result.compareTo(max);
  499           boolean minOk = sigMin > 0 || sigMin == 0 && minInclusive;
  500           boolean maxOk = sigMax < 0 || sigMax == 0 && maxInclusive;
  501   
  502           // Compute the minimum increment
  503           xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_FRACTION_DIGITS);
  504           int fractionDigits = -1;
  505           BigDecimal increment;
  506           if (xmlD == null)
  507               increment = new BigDecimal(1);
  508           else
  509           {
  510               fractionDigits = xmlD.getBigDecimalValue().intValue();
  511               if (fractionDigits > 0)
  512               {
  513                   StringBuffer sb = new StringBuffer("0.");
  514                   for (int i = 1; i < fractionDigits; i++)
  515                       sb.append('0');
  516                   sb.append('1');
  517                   increment = new BigDecimal(sb.toString());
  518               }
  519               else
  520                   increment = new BigDecimal(1.0);
  521           }
  522   
  523           if (minOk && maxOk)
  524           {
  525               // OK 
  526           }
  527           else if (minOk && !maxOk)
  528           {
  529               // TOO BIG
  530               if (maxInclusive)
  531                   result = max;
  532               else
  533                   result = max.subtract(increment);
  534           }
  535           else if (!minOk && maxOk)
  536           {
  537               // TOO SMALL
  538               if (minInclusive)
  539                   result = min;
  540               else
  541                   result = min.add(increment);
  542           }
  543           else
  544           {
  545               // MIN > MAX!!
  546           }
  547   
  548           // We have the number
  549           // Adjust the scale according to the totalDigits and fractionDigits
  550           int digits = 0;
  551           BigDecimal ONE = new BigDecimal(BigInteger.ONE);
  552           for (BigDecimal n = result; n.abs().compareTo(ONE) >= 0; digits++)
  553               n = n.movePointLeft(1);
  554   
  555           if (fractionDigits > 0)
  556               if (totalDigits >= 0)
  557                   result = result.setScale(Math.max(fractionDigits, totalDigits - digits));
  558               else
  559                   result = result.setScale(fractionDigits);
  560           else if (fractionDigits == 0)
  561               result = result.setScale(0);
  562   
  563           return result.toString();
  564       }
  565   
  566       private String formatDuration(SchemaType sType)
  567       {
  568           XmlDuration d =
  569               (XmlDuration) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  570           GDuration minInclusive = null;
  571           if (d != null)
  572               minInclusive = d.getGDurationValue();
  573   
  574           d = (XmlDuration) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  575           GDuration maxInclusive = null;
  576           if (d != null)
  577               maxInclusive = d.getGDurationValue();
  578   
  579           d = (XmlDuration) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  580           GDuration minExclusive = null;
  581           if (d != null)
  582               minExclusive = d.getGDurationValue();
  583   
  584           d = (XmlDuration) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  585           GDuration maxExclusive = null;
  586           if (d != null)
  587               maxExclusive = d.getGDurationValue();
  588   
  589           GDurationBuilder gdurb = new GDurationBuilder();
  590           BigInteger min, max;
  591   
  592           gdurb.setSecond(pick(800000));
  593           gdurb.setMonth(pick(20));
  594   
  595           // Years
  596           // Months
  597           // Days
  598           // Hours
  599           // Minutes
  600           // Seconds
  601           // Fractions
  602           if (minInclusive != null)
  603           {
  604               if (gdurb.getYear() < minInclusive.getYear())
  605                   gdurb.setYear(minInclusive.getYear());
  606               if (gdurb.getMonth() < minInclusive.getMonth())
  607                   gdurb.setMonth(minInclusive.getMonth());
  608               if (gdurb.getDay() < minInclusive.getDay())
  609                   gdurb.setDay(minInclusive.getDay());
  610               if (gdurb.getHour() < minInclusive.getHour())
  611                   gdurb.setHour(minInclusive.getHour());
  612               if (gdurb.getMinute() < minInclusive.getMinute())
  613                   gdurb.setMinute(minInclusive.getMinute());
  614               if (gdurb.getSecond() < minInclusive.getSecond())
  615                   gdurb.setSecond(minInclusive.getSecond());
  616               if (gdurb.getFraction().compareTo(minInclusive.getFraction()) < 0)
  617                   gdurb.setFraction(minInclusive.getFraction());
  618           }
  619   
  620           if (maxInclusive != null)
  621           {
  622               if (gdurb.getYear() > maxInclusive.getYear())
  623                   gdurb.setYear(maxInclusive.getYear());
  624               if (gdurb.getMonth() > maxInclusive.getMonth())
  625                   gdurb.setMonth(maxInclusive.getMonth());
  626               if (gdurb.getDay() > maxInclusive.getDay())
  627                   gdurb.setDay(maxInclusive.getDay());
  628               if (gdurb.getHour() > maxInclusive.getHour())
  629                   gdurb.setHour(maxInclusive.getHour());
  630               if (gdurb.getMinute() > maxInclusive.getMinute())
  631                   gdurb.setMinute(maxInclusive.getMinute());
  632               if (gdurb.getSecond() > maxInclusive.getSecond())
  633                   gdurb.setSecond(maxInclusive.getSecond());
  634               if (gdurb.getFraction().compareTo(maxInclusive.getFraction()) > 0)
  635                   gdurb.setFraction(maxInclusive.getFraction());
  636           }
  637   
  638           if (minExclusive != null)
  639           {
  640               if (gdurb.getYear() <= minExclusive.getYear())
  641                   gdurb.setYear(minExclusive.getYear()+1);
  642               if (gdurb.getMonth() <= minExclusive.getMonth())
  643                   gdurb.setMonth(minExclusive.getMonth()+1);
  644               if (gdurb.getDay() <= minExclusive.getDay())
  645                   gdurb.setDay(minExclusive.getDay()+1);
  646               if (gdurb.getHour() <= minExclusive.getHour())
  647                   gdurb.setHour(minExclusive.getHour()+1);
  648               if (gdurb.getMinute() <= minExclusive.getMinute())
  649                   gdurb.setMinute(minExclusive.getMinute()+1);
  650               if (gdurb.getSecond() <= minExclusive.getSecond())
  651                   gdurb.setSecond(minExclusive.getSecond()+1);
  652               if (gdurb.getFraction().compareTo(minExclusive.getFraction()) <= 0)
  653                   gdurb.setFraction(minExclusive.getFraction().add(new BigDecimal(0.001)));
  654           }
  655   
  656           if (maxExclusive != null)
  657           {
  658               if (gdurb.getYear() > maxExclusive.getYear())
  659                   gdurb.setYear(maxExclusive.getYear());
  660               if (gdurb.getMonth() > maxExclusive.getMonth())
  661                   gdurb.setMonth(maxExclusive.getMonth());
  662               if (gdurb.getDay() > maxExclusive.getDay())
  663                   gdurb.setDay(maxExclusive.getDay());
  664               if (gdurb.getHour() > maxExclusive.getHour())
  665                   gdurb.setHour(maxExclusive.getHour());
  666               if (gdurb.getMinute() > maxExclusive.getMinute())
  667                   gdurb.setMinute(maxExclusive.getMinute());
  668               if (gdurb.getSecond() > maxExclusive.getSecond())
  669                   gdurb.setSecond(maxExclusive.getSecond());
  670               if (gdurb.getFraction().compareTo(maxExclusive.getFraction()) > 0)
  671                   gdurb.setFraction(maxExclusive.getFraction());
  672           }
  673   
  674           gdurb.normalize();
  675           return gdurb.toString();
  676       }
  677   
  678       private String formatDate(SchemaType sType)
  679       {
  680           GDateBuilder gdateb = new GDateBuilder(new Date(1000L * pick(365 * 24 * 60 * 60) + (30L + pick(20)) * 365 * 24 * 60 * 60 * 1000));
  681           GDate min = null, max = null;
  682           GDate temp;
  683   
  684           // Find the min and the max according to the type
  685           switch (sType.getPrimitiveType().getBuiltinTypeCode())
  686           {
  687               case SchemaType.BTC_DATE_TIME:
  688               {
  689                   XmlDateTime x = (XmlDateTime) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  690                   if (x != null)
  691                       min = x.getGDateValue();
  692                   x = (XmlDateTime) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  693                   if (x != null)
  694                       if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
  695                           min = x.getGDateValue();
  696   
  697                   x = (XmlDateTime) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  698                   if (x != null)
  699                       max = x.getGDateValue();
  700                   x = (XmlDateTime) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  701                   if (x != null)
  702                       if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
  703                           max = x.getGDateValue();
  704                   break;
  705               }
  706               case SchemaType.BTC_TIME:
  707               {
  708                   XmlTime x = (XmlTime) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  709                   if (x != null)
  710                       min = x.getGDateValue();
  711                   x = (XmlTime) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  712                   if (x != null)
  713                       if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
  714                           min = x.getGDateValue();
  715   
  716                   x = (XmlTime) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  717                   if (x != null)
  718                       max = x.getGDateValue();
  719                   x = (XmlTime) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  720                   if (x != null)
  721                       if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
  722                           max = x.getGDateValue();
  723                   break;
  724               }
  725               case SchemaType.BTC_DATE:
  726               {
  727                   XmlDate x = (XmlDate) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  728                   if (x != null)
  729                       min = x.getGDateValue();
  730                   x = (XmlDate) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  731                   if (x != null)
  732                       if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
  733                           min = x.getGDateValue();
  734   
  735                   x = (XmlDate) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  736                   if (x != null)
  737                       max = x.getGDateValue();
  738                   x = (XmlDate) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  739                   if (x != null)
  740                       if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
  741                           max = x.getGDateValue();
  742                   break;
  743               }
  744               case SchemaType.BTC_G_YEAR_MONTH:
  745               {
  746                   XmlGYearMonth x = (XmlGYearMonth) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  747                   if (x != null)
  748                       min = x.getGDateValue();
  749                   x = (XmlGYearMonth) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  750                   if (x != null)
  751                       if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
  752                           min = x.getGDateValue();
  753   
  754                   x = (XmlGYearMonth) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  755                   if (x != null)
  756                       max = x.getGDateValue();
  757                   x = (XmlGYearMonth) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  758                   if (x != null)
  759                       if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
  760                           max = x.getGDateValue();
  761                   break;
  762               }
  763               case SchemaType.BTC_G_YEAR:
  764               {
  765                   XmlGYear x = (XmlGYear) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  766                   if (x != null)
  767                       min = x.getGDateValue();
  768                   x = (XmlGYear) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  769                   if (x != null)
  770                       if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
  771                           min = x.getGDateValue();
  772   
  773                   x = (XmlGYear) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  774                   if (x != null)
  775                       max = x.getGDateValue();
  776                   x = (XmlGYear) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  777                   if (x != null)
  778                       if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
  779                           max = x.getGDateValue();
  780                   break;
  781               }
  782               case SchemaType.BTC_G_MONTH_DAY:
  783               {
  784                   XmlGMonthDay x = (XmlGMonthDay) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  785                   if (x != null)
  786                       min = x.getGDateValue();
  787                   x = (XmlGMonthDay) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  788                   if (x != null)
  789                       if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
  790                           min = x.getGDateValue();
  791   
  792                   x = (XmlGMonthDay) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  793                   if (x != null)
  794                       max = x.getGDateValue();
  795                   x = (XmlGMonthDay) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  796                   if (x != null)
  797                       if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
  798                           max = x.getGDateValue();
  799                   break;
  800               }
  801               case SchemaType.BTC_G_DAY:
  802               {
  803                   XmlGDay x = (XmlGDay) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  804                   if (x != null)
  805                       min = x.getGDateValue();
  806                   x = (XmlGDay) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  807                   if (x != null)
  808                       if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
  809                           min = x.getGDateValue();
  810   
  811                   x = (XmlGDay) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  812                   if (x != null)
  813                       max = x.getGDateValue();
  814                   x = (XmlGDay) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  815                   if (x != null)
  816                       if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
  817                           max = x.getGDateValue();
  818                   break;
  819               }
  820               case SchemaType.BTC_G_MONTH:
  821               {
  822                   XmlGMonth x = (XmlGMonth) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
  823                   if (x != null)
  824                       min = x.getGDateValue();
  825                   x = (XmlGMonth) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
  826                   if (x != null)
  827                       if (min == null || min.compareToGDate(x.getGDateValue()) <= 0)
  828                           min = x.getGDateValue();
  829   
  830                   x = (XmlGMonth) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
  831                   if (x != null)
  832                       max = x.getGDateValue();
  833                   x = (XmlGMonth) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
  834                   if (x != null)
  835                       if (max == null || max.compareToGDate(x.getGDateValue()) >= 0)
  836                           max = x.getGDateValue();
  837                   break;
  838               }
  839           }
  840   
  841           if (min != null && max == null)
  842           {
  843               if (min.compareToGDate(gdateb) >= 0)
  844               {
  845                   // Reset the date to min + (1-8) hours
  846                   Calendar c = gdateb.getCalendar();
  847                   c.add(Calendar.HOUR_OF_DAY, pick(8));
  848                   gdateb = new GDateBuilder(c);
  849               }
  850           }
  851           else if (min == null && max != null)
  852           {
  853               if (max.compareToGDate(gdateb) <= 0)
  854               {
  855                   // Reset the date to max - (1-8) hours
  856                   Calendar c = gdateb.getCalendar();
  857                   c.add(Calendar.HOUR_OF_DAY, 0-pick(8));
  858                   gdateb = new GDateBuilder(c);
  859               }
  860           }
  861           else if (min != null && max != null)
  862           {
  863               if (min.compareToGDate(gdateb) >= 0 || max.compareToGDate(gdateb) <= 0)
  864               {
  865                   // Find a date between the two
  866                   Calendar c = min.getCalendar();
  867                   Calendar cmax = max.getCalendar();
  868                   c.add(Calendar.HOUR_OF_DAY, 1);
  869                   if (c.after(cmax))
  870                   {
  871                       c.add(Calendar.HOUR_OF_DAY, -1);
  872                       c.add(Calendar.MINUTE, 1);
  873                       if (c.after(cmax))
  874                       {
  875                           c.add(Calendar.MINUTE, -1);
  876                           c.add(Calendar.SECOND, 1);
  877                           if (c.after(cmax))
  878                           {
  879                               c.add(Calendar.SECOND, -1);
  880                               c.add(Calendar.MILLISECOND, 1);
  881                               if (c.after(cmax))
  882                                   c.add(Calendar.MILLISECOND, -1);
  883                           }
  884                       }
  885                   }
  886                   gdateb = new GDateBuilder(c);
  887               }
  888           }
  889   
  890           gdateb.setBuiltinTypeCode(sType.getPrimitiveType().getBuiltinTypeCode());
  891           if (pick(2) == 0)
  892               gdateb.clearTimeZone();
  893           return gdateb.toString();
  894       }
  895   
  896       private SchemaType closestBuiltin(SchemaType sType)
  897       {
  898           while (!sType.isBuiltinType())
  899               sType = sType.getBaseType();
  900           return sType;
  901       }
  902   
  903       /**
  904        * Cracks a combined QName of the form URL:localname
  905        */
  906       public static QName crackQName(String qName)
  907       {
  908           String ns;
  909           String name;
  910   
  911           int index = qName.lastIndexOf( ':' );
  912           if (index >= 0)
  913           {
  914               ns   = qName.substring( 0, index );
  915               name = qName.substring( index + 1);
  916           }
  917           else
  918           {
  919               ns   = "";
  920               name = qName;
  921           }
  922   
  923           return new QName(ns, name);
  924       }
  925   
  926   
  927       /**
  928        * Cursor position:
  929        * Before this call:
  930        * <outer><foo/>^</outer>  (cursor at the ^)
  931        * After this call:
  932        * <<outer><foo/><bar/>som text<etc/>^</outer>
  933        */
  934       private void processParticle(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
  935       {
  936           int loop = determineMinMaxForSample(sp, xmlc);
  937   
  938           while (loop-- > 0)
  939           {
  940               switch (sp.getParticleType())
  941               {
  942                   case (SchemaParticle.ELEMENT) :
  943                       processElement(sp, xmlc, mixed);
  944                       break;
  945                   case (SchemaParticle.SEQUENCE) :
  946                       processSequence(sp, xmlc, mixed);
  947                       break;
  948                   case (SchemaParticle.CHOICE) :
  949                       processChoice(sp, xmlc, mixed);
  950                       break;
  951                   case (SchemaParticle.ALL) :
  952                       processAll(sp, xmlc, mixed);
  953                       break;
  954                   case (SchemaParticle.WILDCARD) :
  955                       processWildCard(sp, xmlc, mixed);
  956                       break;
  957                   default :
  958                       // throw new Exception("No Match on Schema Particle Type: " + String.valueOf(sp.getParticleType()));
  959               }
  960           }
  961       }
  962   
  963       private int determineMinMaxForSample(SchemaParticle sp, XmlCursor xmlc)
  964       {
  965           int minOccurs = sp.getIntMinOccurs();
  966           int maxOccurs = sp.getIntMaxOccurs();
  967           
  968           if (minOccurs == maxOccurs)
  969               return minOccurs;
  970           
  971           int result = minOccurs;
  972           if (result == 0 && _nElements < MAX_ELEMENTS)
  973               result = 1;
  974           
  975           if (sp.getParticleType() != SchemaParticle.ELEMENT)
  976               return result;
  977           
  978           // it probably only makes sense to put comments in front of individual elements that repeat
  979           
  980           if (sp.getMaxOccurs() == null)
  981           {
  982               // xmlc.insertComment("The next " + getItemNameOrType(sp, xmlc) + " may be repeated " + minOccurs + " or more times");
  983               if (minOccurs == 0)
  984                   xmlc.insertComment("Zero or more repetitions:");
  985               else
  986                   xmlc.insertComment(minOccurs + " or more repetitions:");
  987           }
  988           else if (sp.getIntMaxOccurs() > 1)
  989           {
  990               xmlc.insertComment(minOccurs + " to " + String.valueOf(sp.getMaxOccurs()) + " repetitions:");
  991           }
  992           else
  993           {
  994               xmlc.insertComment("Optional:");
  995           }
  996           return result;
  997       }
  998   
  999       /*
 1000        Return a name for the element or the particle type to use in the comment for minoccurs, max occurs
 1001       */
 1002       private String getItemNameOrType(SchemaParticle sp, XmlCursor xmlc)
 1003       {
 1004           String elementOrTypeName = null;
 1005           if (sp.getParticleType() == SchemaParticle.ELEMENT)
 1006           {
 1007               elementOrTypeName = "Element (" + sp.getName().getLocalPart() + ")";
 1008           }
 1009           else
 1010           {
 1011               elementOrTypeName = printParticleType(sp.getParticleType());
 1012           }
 1013           return elementOrTypeName;
 1014       }
 1015   
 1016       private void processElement(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
 1017       {
 1018           // cast as schema local element
 1019           SchemaLocalElement element = (SchemaLocalElement) sp;
 1020           /// ^  -> <elemenname></elem>^
 1021           if (_soapEnc)
 1022               xmlc.insertElement(element.getName().getLocalPart()); // soap encoded? drop namespaces.
 1023           else
 1024               xmlc.insertElement(element.getName().getLocalPart(), element.getName().getNamespaceURI());
 1025           _nElements++;
 1026           /// -> <elem>^</elem>
 1027           xmlc.toPrevToken();
 1028           // -> <elem>stuff^</elem>
 1029   
 1030           createSampleForType(element.getType(), xmlc);
 1031           // -> <elem>stuff</elem>^
 1032           xmlc.toNextToken();
 1033   
 1034       }
 1035   
 1036       private void moveToken(int numToMove, XmlCursor xmlc)
 1037       {
 1038           for (int i = 0; i < Math.abs(numToMove); i++)
 1039           {
 1040               if (numToMove < 0)
 1041               {
 1042                   xmlc.toPrevToken();
 1043               }
 1044               else
 1045               {
 1046                   xmlc.toNextToken();
 1047               }
 1048           }
 1049       }
 1050       
 1051       private static final String formatQName(XmlCursor xmlc, QName qName)
 1052       {
 1053           XmlCursor parent = xmlc.newCursor();
 1054           parent.toParent();
 1055           String prefix = parent.prefixForNamespace(qName.getNamespaceURI());
 1056           parent.dispose();
 1057           String name;
 1058           if (prefix == null || prefix.length() == 0)
 1059               name = qName.getLocalPart();
 1060           else
 1061               name = prefix + ":" + qName.getLocalPart();
 1062           return name;
 1063       }
 1064       
 1065       private static final QName HREF = new QName("href"); 
 1066       private static final QName ID = new QName("id"); 
 1067       private static final QName XSI_TYPE = new QName("http://www.w3.org/2001/XMLSchema-instance", "type"); 
 1068       private static final QName ENC_ARRAYTYPE = new QName("http://schemas.xmlsoap.org/soap/encoding/", "arrayType");
 1069       private static final QName ENC_OFFSET = new QName("http://schemas.xmlsoap.org/soap/encoding/", "offset");
 1070       
 1071       private static final Set SKIPPED_SOAP_ATTRS = new HashSet(Arrays.asList(new QName[] { HREF, ID, ENC_OFFSET}));
 1072       private void processAttributes(SchemaType stype, XmlCursor xmlc)
 1073       {
 1074           if (_soapEnc)
 1075           {
 1076               QName typeName = stype.getName();
 1077               if (typeName != null)
 1078               {
 1079                   xmlc.insertAttributeWithValue(XSI_TYPE, formatQName(xmlc, typeName));
 1080               }
 1081           }
 1082           
 1083           SchemaProperty[] attrProps = stype.getAttributeProperties();
 1084           for (int i = 0; i < attrProps.length; i++)
 1085           {
 1086               SchemaProperty attr = attrProps[i];
 1087               if (_soapEnc)
 1088               {
 1089                   if (SKIPPED_SOAP_ATTRS.contains(attr.getName()))
 1090                       continue;
 1091                   if (ENC_ARRAYTYPE.equals(attr.getName()))
 1092                   {
 1093                       SOAPArrayType arrayType = ((SchemaWSDLArrayType)stype.getAttributeModel().getAttribute(attr.getName())).getWSDLArrayType();
 1094                       if (arrayType != null)
 1095                           xmlc.insertAttributeWithValue(attr.getName(), formatQName(xmlc, arrayType.getQName()) + arrayType.soap11DimensionString());
 1096                       continue;
 1097                   }
 1098               }
 1099               String defaultValue = attr.getDefaultText();
 1100               xmlc.insertAttributeWithValue(attr.getName(), defaultValue == null ?
 1101                   sampleDataForSimpleType(attr.getType()) : defaultValue);
 1102           }
 1103       }
 1104   
 1105       private void processSequence(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
 1106       {
 1107           SchemaParticle[] spc = sp.getParticleChildren();
 1108           for (int i=0; i < spc.length; i++)
 1109           {
 1110               /// <parent>maybestuff^</parent>
 1111               processParticle(spc[i], xmlc, mixed);
 1112               //<parent>maybestuff...morestuff^</parent>
 1113               if (mixed && i < spc.length-1)
 1114                   xmlc.insertChars(pick(WORDS));
 1115           }
 1116       }
 1117   
 1118       private void processChoice(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
 1119       {
 1120           SchemaParticle[] spc = sp.getParticleChildren();
 1121           xmlc.insertComment("You have a CHOICE of the next " + String.valueOf(spc.length) + " items at this level");
 1122           for (int i=0; i < spc.length; i++)
 1123           {
 1124               processParticle(spc[i], xmlc, mixed);
 1125           }
 1126       }
 1127   
 1128       private void processAll(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
 1129       {
 1130           SchemaParticle[] spc = sp.getParticleChildren();
 1131           // xmlc.insertComment("You may enter the following " + String.valueOf(spc.length) + " items in any order");
 1132           for (int i=0; i < spc.length; i++)
 1133           {
 1134               processParticle(spc[i], xmlc, mixed);
 1135               if (mixed && i < spc.length-1)
 1136                   xmlc.insertChars(pick(WORDS));
 1137           }
 1138       }
 1139   
 1140       private void processWildCard(SchemaParticle sp, XmlCursor xmlc, boolean mixed)
 1141       {
 1142           xmlc.insertComment("You may enter ANY elements at this point");
 1143           xmlc.insertElement("AnyElement");
 1144       }
 1145   
 1146       /**
 1147        * This method will get the base type for the schema type
 1148        */
 1149       
 1150       private static QName getClosestName(SchemaType sType)
 1151       {
 1152           while (sType.getName() == null)
 1153               sType = sType.getBaseType();
 1154   
 1155           return sType.getName();
 1156       }
 1157   
 1158       private String printParticleType(int particleType)
 1159       {
 1160           StringBuffer returnParticleType = new StringBuffer();
 1161           returnParticleType.append("Schema Particle Type: ");
 1162   
 1163           switch (particleType)
 1164           {
 1165               case SchemaParticle.ALL :
 1166                   returnParticleType.append("ALL\n");
 1167                   break;
 1168               case SchemaParticle.CHOICE :
 1169                   returnParticleType.append("CHOICE\n");
 1170                   break;
 1171               case SchemaParticle.ELEMENT :
 1172                   returnParticleType.append("ELEMENT\n");
 1173                   break;
 1174               case SchemaParticle.SEQUENCE :
 1175                   returnParticleType.append("SEQUENCE\n");
 1176                   break;
 1177               case SchemaParticle.WILDCARD :
 1178                   returnParticleType.append("WILDCARD\n");
 1179                   break;
 1180               default :
 1181                   returnParticleType.append("Schema Particle Type Unknown");
 1182                   break;
 1183           }
 1184   
 1185           return returnParticleType.toString();
 1186       }
 1187   
 1188       private ArrayList _typeStack = new ArrayList();
 1189   }

Home » xmlbeans-2.5.0-src » org.apache.xmlbeans.impl » xsd2inst » [javadoc | source]