View Javadoc
1   // =================== DO NOT EDIT THIS FILE ====================
2   // Generated by Modello 2.3.0,
3   // any modifications will be overwritten.
4   // ==============================================================
5   
6   package org.codehaus.modello.test.features.io.stax;
7   
8     //---------------------------------/
9    //- Imported classes and packages -/
10  //---------------------------------/
11  
12  import java.io.IOException;
13  import java.io.OutputStream;
14  import java.io.StringWriter;
15  import java.io.Writer;
16  import java.text.DateFormat;
17  import java.util.Iterator;
18  import java.util.Locale;
19  import java.util.jar.Manifest;
20  import javax.xml.stream.*;
21  import org.codehaus.modello.test.features.Action;
22  import org.codehaus.modello.test.features.AnnotationTest;
23  import org.codehaus.modello.test.features.ArrayFeatures;
24  import org.codehaus.modello.test.features.AssociationFeatures;
25  import org.codehaus.modello.test.features.BaseClass;
26  import org.codehaus.modello.test.features.BidiInList;
27  import org.codehaus.modello.test.features.BidiInSet;
28  import org.codehaus.modello.test.features.Bidirectional;
29  import org.codehaus.modello.test.features.ContentTest;
30  import org.codehaus.modello.test.features.DueTo;
31  import org.codehaus.modello.test.features.Features;
32  import org.codehaus.modello.test.features.File;
33  import org.codehaus.modello.test.features.InterfacesFeature;
34  import org.codehaus.modello.test.features.JavaFeatures;
35  import org.codehaus.modello.test.features.NodeItem;
36  import org.codehaus.modello.test.features.Reference;
37  import org.codehaus.modello.test.features.SimpleInterface;
38  import org.codehaus.modello.test.features.SimpleTypes;
39  import org.codehaus.modello.test.features.SubClassLevel1;
40  import org.codehaus.modello.test.features.SubClassLevel2;
41  import org.codehaus.modello.test.features.SubClassLevel3;
42  import org.codehaus.modello.test.features.SubInterface;
43  import org.codehaus.modello.test.features.SuperThing;
44  import org.codehaus.modello.test.features.Thing;
45  import org.codehaus.modello.test.features.Thingy;
46  import org.codehaus.modello.test.features.XdocFeatures;
47  import org.codehaus.modello.test.features.XmlAttributes;
48  import org.codehaus.modello.test.features.XmlContent;
49  import org.codehaus.modello.test.features.XmlContentLong;
50  import org.codehaus.modello.test.features.XmlContentLongWithAttributes;
51  import org.codehaus.modello.test.features.XmlFeatures;
52  import org.codehaus.modello.test.features.XmlFieldsOrder;
53  import org.codehaus.modello.test.features.XmlFieldsOrderParent;
54  import org.codehaus.modello.test.features.XmlFieldsOrderParent2;
55  import org.codehaus.modello.test.features.XmlTransientFields;
56  import org.codehaus.modello.test.features.XsdFeatures;
57  import org.codehaus.modello.test.features.other.PackageNameFeature;
58  import org.codehaus.modello.test.features.other.SubInterfaceInPackage;
59  import org.codehaus.plexus.util.xml.Xpp3Dom;
60  
61  /**
62   * Class ModelloFeaturesTestStaxWriter.
63   * 
64   * @version $Revision$ $Date$
65   */
66  @SuppressWarnings( "all" )
67  public class ModelloFeaturesTestStaxWriter
68  {
69  
70        //--------------------------/
71       //- Class/Member Variables -/
72      //--------------------------/
73  
74      /**
75       * Field curId.
76       */
77      private int curId;
78  
79      /**
80       * Field idMap.
81       */
82      private java.util.Map idMap;
83  
84  
85        //----------------/
86       //- Constructors -/
87      //----------------/
88  
89      public ModelloFeaturesTestStaxWriter()
90      {
91          idMap = new java.util.HashMap();
92      } //-- org.codehaus.modello.test.features.io.stax.ModelloFeaturesTestStaxWriter()
93  
94  
95        //-----------/
96       //- Methods -/
97      //-----------/
98  
99      /**
100      * Method write.
101      * 
102      * @param writer a writer object.
103      * @param features a features object.
104      * @throws java.io.IOException java.io.IOException if any.
105      * @throws XMLStreamException XMLStreamException if any.
106      */
107     public void write( Writer writer, Features features )
108         throws java.io.IOException, XMLStreamException
109     {
110         XMLOutputFactory factory = XMLOutputFactory.newInstance();
111         boolean supportWindowsLineEndings = false;
112         if ( factory.isPropertySupported( "com.ctc.wstx.outputEscapeCr" ) )
113         {
114             factory.setProperty( "com.ctc.wstx.outputEscapeCr", Boolean.FALSE );
115             supportWindowsLineEndings = true;
116         }
117         if ( factory.isPropertySupported( "org.codehaus.stax2.automaticEmptyElements" ) )
118         {
119             factory.setProperty( "org.codehaus.stax2.automaticEmptyElements", Boolean.FALSE );
120         }
121         IndentingXMLStreamWriterx/IndentingXMLStreamWriter.html#IndentingXMLStreamWriter">IndentingXMLStreamWriter serializer = new IndentingXMLStreamWriter( factory.createXMLStreamWriter( writer ) );
122         if ( supportWindowsLineEndings )
123         {
124             serializer.setNewLine( serializer.getLineSeparator() );
125         }
126         serializer.writeStartDocument( features.getModelEncoding(), "1.0" );
127         writeFeatures( features, "features-demo", serializer );
128         serializer.writeEndDocument();
129     } //-- void write( Writer, Features )
130 
131     /**
132      * Method write.
133      * 
134      * @param stream a stream object.
135      * @param features a features object.
136      * @throws java.io.IOException java.io.IOException if any.
137      * @throws XMLStreamException XMLStreamException if any.
138      */
139     public void write( OutputStream stream, Features features )
140         throws java.io.IOException, XMLStreamException
141     {
142         XMLOutputFactory factory = XMLOutputFactory.newInstance();
143         boolean supportWindowsLineEndings = false;
144         if ( factory.isPropertySupported( "com.ctc.wstx.outputEscapeCr" ) )
145         {
146             factory.setProperty( "com.ctc.wstx.outputEscapeCr", Boolean.FALSE );
147             supportWindowsLineEndings = true;
148         }
149         if ( factory.isPropertySupported( "org.codehaus.stax2.automaticEmptyElements" ) )
150         {
151             factory.setProperty( "org.codehaus.stax2.automaticEmptyElements", Boolean.FALSE );
152         }
153         IndentingXMLStreamWriterx/IndentingXMLStreamWriter.html#IndentingXMLStreamWriter">IndentingXMLStreamWriter serializer = new IndentingXMLStreamWriter( factory.createXMLStreamWriter( stream, features.getModelEncoding() ) );
154         if ( supportWindowsLineEndings )
155         {
156             serializer.setNewLine( serializer.getLineSeparator() );
157         }
158         serializer.writeStartDocument( features.getModelEncoding(), "1.0" );
159         writeFeatures( features, "features-demo", serializer );
160         serializer.writeEndDocument();
161     } //-- void write( OutputStream, Features )
162 
163     /**
164      * Method writeAction.
165      * 
166      * @param action a action object.
167      * @param serializer a serializer object.
168      * @param tagName a tagName object.
169      * @throws java.io.IOException java.io.IOException if any.
170      * @throws XMLStreamException XMLStreamException if any.
171      */
172     private void writeAction( Action action, String tagName, XMLStreamWriter serializer )
173         throws java.io.IOException, XMLStreamException
174     {
175         if ( action != null )
176         {
177             serializer.writeStartElement( tagName );
178             if ( action.getDev() != null )
179             {
180                 serializer.writeAttribute( "dev", action.getDev() );
181             }
182             serializer.writeCharacters( action.getAction() );
183             serializer.writeEndElement();
184         }
185     } //-- void writeAction( Action, String, XMLStreamWriter )
186 
187     /**
188      * Method writeAnnotationTest.
189      * 
190      * @param annotationTest a annotationTest object.
191      * @param serializer a serializer object.
192      * @param tagName a tagName object.
193      * @throws java.io.IOException java.io.IOException if any.
194      * @throws XMLStreamException XMLStreamException if any.
195      */
196     private void writeAnnotationTest( AnnotationTest annotationTest, String tagName, XMLStreamWriter serializer )
197         throws java.io.IOException, XMLStreamException
198     {
199         if ( annotationTest != null )
200         {
201             serializer.writeStartElement( tagName );
202             if ( annotationTest.getAnyField() != null )
203             {
204                 serializer.writeStartElement( "anyField" );
205                 serializer.writeCharacters( annotationTest.getAnyField() );
206                 serializer.writeEndElement();
207             }
208             serializer.writeEndElement();
209         }
210     } //-- void writeAnnotationTest( AnnotationTest, String, XMLStreamWriter )
211 
212     /**
213      * Method writeArrayFeatures.
214      * 
215      * @param arrayFeatures a arrayFeatures object.
216      * @param serializer a serializer object.
217      * @param tagName a tagName object.
218      * @throws java.io.IOException java.io.IOException if any.
219      * @throws XMLStreamException XMLStreamException if any.
220      */
221     private void writeArrayFeatures( ArrayFeatures arrayFeatures, String tagName, XMLStreamWriter serializer )
222         throws java.io.IOException, XMLStreamException
223     {
224         if ( arrayFeatures != null )
225         {
226             serializer.writeStartElement( tagName );
227             serializer.writeEndElement();
228         }
229     } //-- void writeArrayFeatures( ArrayFeatures, String, XMLStreamWriter )
230 
231     /**
232      * Method writeAssociationFeatures.
233      * 
234      * @param associationFeatures a associationFeatures object.
235      * @param serializer a serializer object.
236      * @param tagName a tagName object.
237      * @throws java.io.IOException java.io.IOException if any.
238      * @throws XMLStreamException XMLStreamException if any.
239      */
240     private void writeAssociationFeatures( AssociationFeatures associationFeatures, String tagName, XMLStreamWriter serializer )
241         throws java.io.IOException, XMLStreamException
242     {
243         if ( associationFeatures != null )
244         {
245             serializer.writeStartElement( tagName );
246             if ( ( associationFeatures.getListReferences() != null ) && ( associationFeatures.getListReferences().size() > 0 ) )
247             {
248                 serializer.writeStartElement( "listReferences" );
249                 for ( Iterator iter = associationFeatures.getListReferences().iterator(); iter.hasNext(); )
250                 {
251                     Reference="../../../../../../../org/codehaus/modello/test/features/Reference.html#Reference">Reference o = (Reference) iter.next();
252                     writeReference( o, "listReference", serializer );
253                 }
254                 serializer.writeEndElement();
255             }
256             if ( ( associationFeatures.getSetReferences() != null ) && ( associationFeatures.getSetReferences().size() > 0 ) )
257             {
258                 serializer.writeStartElement( "setReferences" );
259                 for ( Iterator iter = associationFeatures.getSetReferences().iterator(); iter.hasNext(); )
260                 {
261                     Reference="../../../../../../../org/codehaus/modello/test/features/Reference.html#Reference">Reference o = (Reference) iter.next();
262                     writeReference( o, "setReference", serializer );
263                 }
264                 serializer.writeEndElement();
265             }
266             if ( ( associationFeatures.getListStrings() != null ) && ( associationFeatures.getListStrings().size() > 0 ) )
267             {
268                 serializer.writeStartElement( "listStrings" );
269                 for ( Iterator iter = associationFeatures.getListStrings().iterator(); iter.hasNext(); )
270                 {
271                     String listString = (String) iter.next();
272                     serializer.writeStartElement( "listString" );
273                     serializer.writeCharacters( listString );
274                     serializer.writeEndElement();
275                 }
276                 serializer.writeEndElement();
277             }
278             if ( ( associationFeatures.getSetStrings() != null ) && ( associationFeatures.getSetStrings().size() > 0 ) )
279             {
280                 serializer.writeStartElement( "setStrings" );
281                 for ( Iterator iter = associationFeatures.getSetStrings().iterator(); iter.hasNext(); )
282                 {
283                     String setString = (String) iter.next();
284                     serializer.writeStartElement( "setString" );
285                     serializer.writeCharacters( setString );
286                     serializer.writeEndElement();
287                 }
288                 serializer.writeEndElement();
289             }
290             if ( ( associationFeatures.getProperties() != null ) && ( associationFeatures.getProperties().size() > 0 ) )
291             {
292                 serializer.writeStartElement( "properties" );
293                 for ( Iterator iter = associationFeatures.getProperties().keySet().iterator(); iter.hasNext(); )
294                 {
295                     String key = (String) iter.next();
296                     String value = (String) associationFeatures.getProperties().get( key );
297                     serializer.writeStartElement( "" + key + "" );
298                     serializer.writeCharacters( value );
299                     serializer.writeEndElement();
300                 }
301                 serializer.writeEndElement();
302             }
303             if ( associationFeatures.getBidi() != null )
304             {
305                 writeBidirectional( (Bidirectional) associationFeatures.getBidi(), "bidi", serializer );
306             }
307             if ( ( associationFeatures.getListOfBidis() != null ) && ( associationFeatures.getListOfBidis().size() > 0 ) )
308             {
309                 serializer.writeStartElement( "listOfBidis" );
310                 for ( Iterator iter = associationFeatures.getListOfBidis().iterator(); iter.hasNext(); )
311                 {
312                     BidiInList"../../../../../../../org/codehaus/modello/test/features/BidiInList.html#BidiInList">BidiInList o = (BidiInList) iter.next();
313                     writeBidiInList( o, "listOfBidi", serializer );
314                 }
315                 serializer.writeEndElement();
316             }
317             if ( ( associationFeatures.getSetOfBidis() != null ) && ( associationFeatures.getSetOfBidis().size() > 0 ) )
318             {
319                 serializer.writeStartElement( "setOfBidis" );
320                 for ( Iterator iter = associationFeatures.getSetOfBidis().iterator(); iter.hasNext(); )
321                 {
322                     BidiInSet="../../../../../../../org/codehaus/modello/test/features/BidiInSet.html#BidiInSet">BidiInSet o = (BidiInSet) iter.next();
323                     writeBidiInSet( o, "setOfBidi", serializer );
324                 }
325                 serializer.writeEndElement();
326             }
327             serializer.writeEndElement();
328         }
329     } //-- void writeAssociationFeatures( AssociationFeatures, String, XMLStreamWriter )
330 
331     /**
332      * Method writeBaseClass.
333      * 
334      * @param baseClass a baseClass object.
335      * @param serializer a serializer object.
336      * @param tagName a tagName object.
337      * @throws java.io.IOException java.io.IOException if any.
338      * @throws XMLStreamException XMLStreamException if any.
339      */
340     private void writeBaseClass( BaseClass baseClass, String tagName, XMLStreamWriter serializer )
341         throws java.io.IOException, XMLStreamException
342     {
343         if ( baseClass != null )
344         {
345             serializer.writeStartElement( tagName );
346             if ( baseClass.getBaseAttribute() != 0 )
347             {
348                 serializer.writeAttribute( "baseAttribute", String.valueOf( baseClass.getBaseAttribute() ) );
349             }
350             if ( baseClass.getBaseElement() != 0 )
351             {
352                 serializer.writeStartElement( "baseElement" );
353                 serializer.writeCharacters( String.valueOf( baseClass.getBaseElement() ) );
354                 serializer.writeEndElement();
355             }
356             serializer.writeEndElement();
357         }
358     } //-- void writeBaseClass( BaseClass, String, XMLStreamWriter )
359 
360     /**
361      * Method writeBidiInList.
362      * 
363      * @param bidiInList a bidiInList object.
364      * @param serializer a serializer object.
365      * @param tagName a tagName object.
366      * @throws java.io.IOException java.io.IOException if any.
367      * @throws XMLStreamException XMLStreamException if any.
368      */
369     private void writeBidiInList( BidiInList bidiInList, String tagName, XMLStreamWriter serializer )
370         throws java.io.IOException, XMLStreamException
371     {
372         if ( bidiInList != null )
373         {
374             serializer.writeStartElement( tagName );
375             if ( bidiInList.getParent() != null )
376             {
377                 writeAssociationFeatures( (AssociationFeatures) bidiInList.getParent(), "parent", serializer );
378             }
379             serializer.writeEndElement();
380         }
381     } //-- void writeBidiInList( BidiInList, String, XMLStreamWriter )
382 
383     /**
384      * Method writeBidiInSet.
385      * 
386      * @param bidiInSet a bidiInSet object.
387      * @param serializer a serializer object.
388      * @param tagName a tagName object.
389      * @throws java.io.IOException java.io.IOException if any.
390      * @throws XMLStreamException XMLStreamException if any.
391      */
392     private void writeBidiInSet( BidiInSet bidiInSet, String tagName, XMLStreamWriter serializer )
393         throws java.io.IOException, XMLStreamException
394     {
395         if ( bidiInSet != null )
396         {
397             serializer.writeStartElement( tagName );
398             if ( bidiInSet.getParent() != null )
399             {
400                 writeAssociationFeatures( (AssociationFeatures) bidiInSet.getParent(), "parent", serializer );
401             }
402             serializer.writeEndElement();
403         }
404     } //-- void writeBidiInSet( BidiInSet, String, XMLStreamWriter )
405 
406     /**
407      * Method writeBidirectional.
408      * 
409      * @param bidirectional a bidirectional object.
410      * @param serializer a serializer object.
411      * @param tagName a tagName object.
412      * @throws java.io.IOException java.io.IOException if any.
413      * @throws XMLStreamException XMLStreamException if any.
414      */
415     private void writeBidirectional( Bidirectional bidirectional, String tagName, XMLStreamWriter serializer )
416         throws java.io.IOException, XMLStreamException
417     {
418         if ( bidirectional != null )
419         {
420             serializer.writeStartElement( tagName );
421             if ( bidirectional.getParent() != null )
422             {
423                 writeAssociationFeatures( (AssociationFeatures) bidirectional.getParent(), "parent", serializer );
424             }
425             serializer.writeEndElement();
426         }
427     } //-- void writeBidirectional( Bidirectional, String, XMLStreamWriter )
428 
429     /**
430      * Method writeContentTest.
431      * 
432      * @param contentTest a contentTest object.
433      * @param serializer a serializer object.
434      * @param tagName a tagName object.
435      * @throws java.io.IOException java.io.IOException if any.
436      * @throws XMLStreamException XMLStreamException if any.
437      */
438     private void writeContentTest( ContentTest contentTest, String tagName, XMLStreamWriter serializer )
439         throws java.io.IOException, XMLStreamException
440     {
441         if ( contentTest != null )
442         {
443             serializer.writeStartElement( tagName );
444             if ( contentTest.getAttr() != null )
445             {
446                 serializer.writeAttribute( "attr", contentTest.getAttr() );
447             }
448             if ( contentTest.getAttr2() != 0 )
449             {
450                 serializer.writeAttribute( "attr2", String.valueOf( contentTest.getAttr2() ) );
451             }
452             serializer.writeCharacters( contentTest.getContent() );
453             serializer.writeEndElement();
454         }
455     } //-- void writeContentTest( ContentTest, String, XMLStreamWriter )
456 
457     /**
458      * Method writeDom.
459      * 
460      * @param dom a dom object.
461      * @param serializer a serializer object.
462      * @throws XMLStreamException XMLStreamException if any.
463      */
464     private void writeDom( Xpp3Dom dom, XMLStreamWriter serializer )
465         throws XMLStreamException
466     {
467         serializer.writeStartElement( dom.getName() );
468         String[] attributeNames = dom.getAttributeNames();
469         for ( int i = 0; i < attributeNames.length; i++ )
470         {
471             String attributeName = attributeNames[i];
472             serializer.writeAttribute( attributeName, dom.getAttribute( attributeName ) );
473         }
474         Xpp3Dom[] children = dom.getChildren();
475         for ( int i = 0; i < children.length; i++ )
476         {
477             writeDom( children[i], serializer );
478         }
479         String value = dom.getValue();
480         if ( value != null )
481         {
482             serializer.writeCharacters( value );
483         }
484         serializer.writeEndElement();
485     } //-- void writeDom( Xpp3Dom, XMLStreamWriter )
486 
487     /**
488      * Method writeDueTo.
489      * 
490      * @param dueTo a dueTo object.
491      * @param serializer a serializer object.
492      * @param tagName a tagName object.
493      * @throws java.io.IOException java.io.IOException if any.
494      * @throws XMLStreamException XMLStreamException if any.
495      */
496     private void writeDueTo( DueTo dueTo, String tagName, XMLStreamWriter serializer )
497         throws java.io.IOException, XMLStreamException
498     {
499         if ( dueTo != null )
500         {
501             serializer.writeStartElement( tagName );
502             if ( dueTo.getName() != null )
503             {
504                 serializer.writeAttribute( "name", dueTo.getName() );
505             }
506             if ( dueTo.getEmail() != null )
507             {
508                 serializer.writeAttribute( "email", dueTo.getEmail() );
509             }
510             serializer.writeEndElement();
511         }
512     } //-- void writeDueTo( DueTo, String, XMLStreamWriter )
513 
514     /**
515      * Method writeFeatures.
516      * 
517      * @param features a features object.
518      * @param serializer a serializer object.
519      * @param tagName a tagName object.
520      * @throws java.io.IOException java.io.IOException if any.
521      * @throws XMLStreamException XMLStreamException if any.
522      */
523     private void writeFeatures( Features features, String tagName, XMLStreamWriter serializer )
524         throws java.io.IOException, XMLStreamException
525     {
526         if ( features != null )
527         {
528             serializer.setDefaultNamespace( "http://codehaus-plexus.github.io/FEATURES/1.0.0" );
529             serializer.writeStartElement( tagName );
530             serializer.writeDefaultNamespace( "http://codehaus-plexus.github.io/FEATURES/1.0.0" );
531             serializer.setPrefix( "xsi", "http://www.w3.org/2001/XMLSchema-instance" );
532             serializer.writeNamespace( "xsi", "http://www.w3.org/2001/XMLSchema-instance" );
533             serializer.writeAttribute( "http://www.w3.org/2001/XMLSchema-instance", "schemaLocation", "http://codehaus-plexus.github.io/FEATURES/1.0.0 http://codehaus-plexus.github.io/features-1.0.0.xsd" );
534             if ( features.getVersionField() != null )
535             {
536                 serializer.writeStartElement( "versionField" );
537                 serializer.writeCharacters( features.getVersionField() );
538                 serializer.writeEndElement();
539             }
540             if ( features.getComment() != null )
541             {
542                 serializer.writeStartElement( "comment" );
543                 serializer.writeCharacters( features.getComment() );
544                 serializer.writeEndElement();
545             }
546             if ( features.getDescription() != null )
547             {
548                 serializer.writeStartElement( "description" );
549                 serializer.writeCharacters( features.getDescription() );
550                 serializer.writeEndElement();
551             }
552             if ( features.getRequired() != null )
553             {
554                 serializer.writeStartElement( "required" );
555                 serializer.writeCharacters( features.getRequired() );
556                 serializer.writeEndElement();
557             }
558             if ( features.getIdentifier() != null )
559             {
560                 serializer.writeStartElement( "identifier" );
561                 serializer.writeCharacters( features.getIdentifier() );
562                 serializer.writeEndElement();
563             }
564             if ( features.getIdentifierPart2() != null )
565             {
566                 writeReference( (Reference) features.getIdentifierPart2(), "identifierPart2", serializer );
567             }
568             if ( features.getSimpleTypes() != null )
569             {
570                 writeSimpleTypes( (SimpleTypes) features.getSimpleTypes(), "simpleTypes", serializer );
571             }
572             if ( features.getDefaultValues() != null )
573             {
574                 writeSimpleTypes( (SimpleTypes) features.getDefaultValues(), "defaultValues", serializer );
575             }
576             if ( features.getArrays() != null )
577             {
578                 writeArrayFeatures( (ArrayFeatures) features.getArrays(), "arrays", serializer );
579             }
580             if ( features.getAssociationFeatures() != null )
581             {
582                 writeAssociationFeatures( (AssociationFeatures) features.getAssociationFeatures(), "associationFeatures", serializer );
583             }
584             if ( features.getJavaFeatures() != null )
585             {
586                 writeJavaFeatures( (JavaFeatures) features.getJavaFeatures(), "javaFeatures", serializer );
587             }
588             if ( features.getXmlFeatures() != null )
589             {
590                 writeXmlFeatures( (XmlFeatures) features.getXmlFeatures(), "xmlFeatures", serializer );
591             }
592             if ( features.getXdocFeatures() != null )
593             {
594                 writeXdocFeatures( (XdocFeatures) features.getXdocFeatures(), "xdocFeatures", serializer );
595             }
596             if ( features.getNode() != null )
597             {
598                 writeNodeItem( (NodeItem) features.getNode(), "node", serializer );
599             }
600             if ( features.getCloneable() != null )
601             {
602                 writeThing( (Thing) features.getCloneable(), "cloneable", serializer );
603             }
604             if ( features.getFile() != null )
605             {
606                 writeFile( (File) features.getFile(), "file", serializer );
607             }
608             if ( features.getAction() != null )
609             {
610                 writeAction( (Action) features.getAction(), "action", serializer );
611             }
612             serializer.writeEndElement();
613         }
614     } //-- void writeFeatures( Features, String, XMLStreamWriter )
615 
616     /**
617      * Method writeFile.
618      * 
619      * @param file a file object.
620      * @param serializer a serializer object.
621      * @param tagName a tagName object.
622      * @throws java.io.IOException java.io.IOException if any.
623      * @throws XMLStreamException XMLStreamException if any.
624      */
625     private void writeFile( File file, String tagName, XMLStreamWriter serializer )
626         throws java.io.IOException, XMLStreamException
627     {
628         if ( file != null )
629         {
630             serializer.writeStartElement( tagName );
631             if ( file.getFile() != null )
632             {
633                 serializer.writeStartElement( "file" );
634                 serializer.writeCharacters( file.getFile() );
635                 serializer.writeEndElement();
636             }
637             serializer.writeEndElement();
638         }
639     } //-- void writeFile( File, String, XMLStreamWriter )
640 
641     /**
642      * Method writeInterfacesFeature.
643      * 
644      * @param interfacesFeature a interfacesFeature object.
645      * @param serializer a serializer object.
646      * @param tagName a tagName object.
647      * @throws java.io.IOException java.io.IOException if any.
648      * @throws XMLStreamException XMLStreamException if any.
649      */
650     private void writeInterfacesFeature( InterfacesFeature interfacesFeature, String tagName, XMLStreamWriter serializer )
651         throws java.io.IOException, XMLStreamException
652     {
653         if ( interfacesFeature != null )
654         {
655             serializer.writeStartElement( tagName );
656             if ( interfacesFeature.getId() != null )
657             {
658                 serializer.writeStartElement( "id" );
659                 serializer.writeCharacters( interfacesFeature.getId() );
660                 serializer.writeEndElement();
661             }
662             serializer.writeEndElement();
663         }
664     } //-- void writeInterfacesFeature( InterfacesFeature, String, XMLStreamWriter )
665 
666     /**
667      * Method writeJavaFeatures.
668      * 
669      * @param javaFeatures a javaFeatures object.
670      * @param serializer a serializer object.
671      * @param tagName a tagName object.
672      * @throws java.io.IOException java.io.IOException if any.
673      * @throws XMLStreamException XMLStreamException if any.
674      */
675     private void writeJavaFeatures( JavaFeatures javaFeatures, String tagName, XMLStreamWriter serializer )
676         throws java.io.IOException, XMLStreamException
677     {
678         if ( javaFeatures != null )
679         {
680             serializer.writeStartElement( tagName );
681             if ( javaFeatures.getInterfaces() != null )
682             {
683                 writeInterfacesFeature( (InterfacesFeature) javaFeatures.getInterfaces(), "interfaces", serializer );
684             }
685             if ( javaFeatures.getPackageName() != null )
686             {
687                 writePackageNameFeature( (PackageNameFeature) javaFeatures.getPackageName(), "packageName", serializer );
688             }
689             if ( javaFeatures.getBase() != null )
690             {
691                 writeBaseClass( (BaseClass) javaFeatures.getBase(), "base", serializer );
692             }
693             if ( javaFeatures.getSubClass() != null )
694             {
695                 writeSubClassLevel1( (SubClassLevel1) javaFeatures.getSubClass(), "subClass", serializer );
696             }
697             if ( javaFeatures.getSubClass2() != null )
698             {
699                 writeSubClassLevel2( (SubClassLevel2) javaFeatures.getSubClass2(), "subClass2", serializer );
700             }
701             if ( javaFeatures.getSubClass3() != null )
702             {
703                 writeSubClassLevel3( (SubClassLevel3) javaFeatures.getSubClass3(), "subClass3", serializer );
704             }
705             if ( javaFeatures.getAnnotation() != null )
706             {
707                 writeAnnotationTest( (AnnotationTest) javaFeatures.getAnnotation(), "annotation", serializer );
708             }
709             serializer.writeEndElement();
710         }
711     } //-- void writeJavaFeatures( JavaFeatures, String, XMLStreamWriter )
712 
713     /**
714      * Method writeNodeItem.
715      * 
716      * @param nodeItem a nodeItem object.
717      * @param serializer a serializer object.
718      * @param tagName a tagName object.
719      * @throws java.io.IOException java.io.IOException if any.
720      * @throws XMLStreamException XMLStreamException if any.
721      */
722     private void writeNodeItem( NodeItem nodeItem, String tagName, XMLStreamWriter serializer )
723         throws java.io.IOException, XMLStreamException
724     {
725         if ( nodeItem != null )
726         {
727             serializer.writeStartElement( tagName );
728             if ( nodeItem.getValue() != null )
729             {
730                 serializer.writeStartElement( "value" );
731                 serializer.writeCharacters( nodeItem.getValue() );
732                 serializer.writeEndElement();
733             }
734             if ( nodeItem.getChild() != null )
735             {
736                 writeNodeItem( (NodeItem) nodeItem.getChild(), "child", serializer );
737             }
738             serializer.writeEndElement();
739         }
740     } //-- void writeNodeItem( NodeItem, String, XMLStreamWriter )
741 
742     /**
743      * Method writePackageNameFeature.
744      * 
745      * @param packageNameFeature a packageNameFeature object.
746      * @param serializer a serializer object.
747      * @param tagName a tagName object.
748      * @throws java.io.IOException java.io.IOException if any.
749      * @throws XMLStreamException XMLStreamException if any.
750      */
751     private void writePackageNameFeature( PackageNameFeature packageNameFeature, String tagName, XMLStreamWriter serializer )
752         throws java.io.IOException, XMLStreamException
753     {
754         if ( packageNameFeature != null )
755         {
756             serializer.writeStartElement( tagName );
757             if ( packageNameFeature.getReference() != null )
758             {
759                 writeReference( (Reference) packageNameFeature.getReference(), "reference", serializer );
760             }
761             serializer.writeEndElement();
762         }
763     } //-- void writePackageNameFeature( PackageNameFeature, String, XMLStreamWriter )
764 
765     /**
766      * Method writeReference.
767      * 
768      * @param reference a reference object.
769      * @param serializer a serializer object.
770      * @param tagName a tagName object.
771      * @throws java.io.IOException java.io.IOException if any.
772      * @throws XMLStreamException XMLStreamException if any.
773      */
774     private void writeReference( Reference reference, String tagName, XMLStreamWriter serializer )
775         throws java.io.IOException, XMLStreamException
776     {
777         if ( reference != null )
778         {
779             serializer.writeStartElement( tagName );
780             if ( reference.getId() != null )
781             {
782                 serializer.writeStartElement( "id" );
783                 serializer.writeCharacters( reference.getId() );
784                 serializer.writeEndElement();
785             }
786             serializer.writeEndElement();
787         }
788     } //-- void writeReference( Reference, String, XMLStreamWriter )
789 
790     /**
791      * Method writeSimpleTypes.
792      * 
793      * @param simpleTypes a simpleTypes object.
794      * @param serializer a serializer object.
795      * @param tagName a tagName object.
796      * @throws java.io.IOException java.io.IOException if any.
797      * @throws XMLStreamException XMLStreamException if any.
798      */
799     private void writeSimpleTypes( SimpleTypes simpleTypes, String tagName, XMLStreamWriter serializer )
800         throws java.io.IOException, XMLStreamException
801     {
802         if ( simpleTypes != null )
803         {
804             serializer.writeStartElement( tagName );
805             if ( simpleTypes.isPrimitiveBoolean() != true )
806             {
807                 serializer.writeStartElement( "primitiveBoolean" );
808                 serializer.writeCharacters( String.valueOf( simpleTypes.isPrimitiveBoolean() ) );
809                 serializer.writeEndElement();
810             }
811             if ( simpleTypes.getPrimitiveChar() != 'H' )
812             {
813                 serializer.writeStartElement( "primitiveChar" );
814                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveChar() ) );
815                 serializer.writeEndElement();
816             }
817             if ( simpleTypes.getPrimitiveByte() != 12 )
818             {
819                 serializer.writeStartElement( "primitiveByte" );
820                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveByte() ) );
821                 serializer.writeEndElement();
822             }
823             if ( simpleTypes.getPrimitiveShort() != 1212 )
824             {
825                 serializer.writeStartElement( "primitiveShort" );
826                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveShort() ) );
827                 serializer.writeEndElement();
828             }
829             if ( simpleTypes.getPrimitiveInt() != 121212 )
830             {
831                 serializer.writeStartElement( "primitiveInt" );
832                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveInt() ) );
833                 serializer.writeEndElement();
834             }
835             if ( simpleTypes.getPrimitiveLong() != 1234567890123L )
836             {
837                 serializer.writeStartElement( "primitiveLong" );
838                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveLong() ) );
839                 serializer.writeEndElement();
840             }
841             if ( simpleTypes.getPrimitiveFloat() != 12.12f )
842             {
843                 serializer.writeStartElement( "primitiveFloat" );
844                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveFloat() ) );
845                 serializer.writeEndElement();
846             }
847             if ( simpleTypes.getPrimitiveDouble() != 12.12 )
848             {
849                 serializer.writeStartElement( "primitiveDouble" );
850                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveDouble() ) );
851                 serializer.writeEndElement();
852             }
853             if ( ( simpleTypes.getObjectString() != null ) && !simpleTypes.getObjectString().equals( "default value" ) )
854             {
855                 serializer.writeStartElement( "objectString" );
856                 serializer.writeCharacters( simpleTypes.getObjectString() );
857                 serializer.writeEndElement();
858             }
859             if ( ( simpleTypes.getObjectDate() != null ) && !simpleTypes.getObjectDate().equals( new java.util.Date( 1356383532012L ) ) )
860             {
861                 serializer.writeStartElement( "objectDate" );
862                 serializer.writeCharacters( new java.text.SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ss.SSS", java.util.Locale.US ).format( simpleTypes.getObjectDate() ) );
863                 serializer.writeEndElement();
864             }
865             if ( simpleTypes.isPrimitiveBooleanNoDefault() != false )
866             {
867                 serializer.writeStartElement( "primitiveBooleanNoDefault" );
868                 serializer.writeCharacters( String.valueOf( simpleTypes.isPrimitiveBooleanNoDefault() ) );
869                 serializer.writeEndElement();
870             }
871             if ( simpleTypes.getPrimitiveCharNoDefault() != '\0' )
872             {
873                 serializer.writeStartElement( "primitiveCharNoDefault" );
874                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveCharNoDefault() ) );
875                 serializer.writeEndElement();
876             }
877             if ( simpleTypes.getPrimitiveByteNoDefault() != 0 )
878             {
879                 serializer.writeStartElement( "primitiveByteNoDefault" );
880                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveByteNoDefault() ) );
881                 serializer.writeEndElement();
882             }
883             if ( simpleTypes.getPrimitiveShortNoDefault() != 0 )
884             {
885                 serializer.writeStartElement( "primitiveShortNoDefault" );
886                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveShortNoDefault() ) );
887                 serializer.writeEndElement();
888             }
889             if ( simpleTypes.getPrimitiveIntNoDefault() != 0 )
890             {
891                 serializer.writeStartElement( "primitiveIntNoDefault" );
892                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveIntNoDefault() ) );
893                 serializer.writeEndElement();
894             }
895             if ( simpleTypes.getPrimitiveLongNoDefault() != 0L )
896             {
897                 serializer.writeStartElement( "primitiveLongNoDefault" );
898                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveLongNoDefault() ) );
899                 serializer.writeEndElement();
900             }
901             if ( simpleTypes.getPrimitiveFloatNoDefault() != 0.0f )
902             {
903                 serializer.writeStartElement( "primitiveFloatNoDefault" );
904                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveFloatNoDefault() ) );
905                 serializer.writeEndElement();
906             }
907             if ( simpleTypes.getPrimitiveDoubleNoDefault() != 0.0 )
908             {
909                 serializer.writeStartElement( "primitiveDoubleNoDefault" );
910                 serializer.writeCharacters( String.valueOf( simpleTypes.getPrimitiveDoubleNoDefault() ) );
911                 serializer.writeEndElement();
912             }
913             if ( simpleTypes.getObjectStringNoDefault() != null )
914             {
915                 serializer.writeStartElement( "objectStringNoDefault" );
916                 serializer.writeCharacters( simpleTypes.getObjectStringNoDefault() );
917                 serializer.writeEndElement();
918             }
919             if ( simpleTypes.getObjectDateNoDefault() != null )
920             {
921                 serializer.writeStartElement( "objectDateNoDefault" );
922                 serializer.writeCharacters( new java.text.SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ss.SSS", java.util.Locale.US ).format( simpleTypes.getObjectDateNoDefault() ) );
923                 serializer.writeEndElement();
924             }
925             if ( simpleTypes.getDom() != null )
926             {
927                 writeDom( (Xpp3Dom) simpleTypes.getDom(), serializer );
928             }
929             if ( simpleTypes.getContent() != null )
930             {
931                 writeContentTest( (ContentTest) simpleTypes.getContent(), "content", serializer );
932             }
933             serializer.writeEndElement();
934         }
935     } //-- void writeSimpleTypes( SimpleTypes, String, XMLStreamWriter )
936 
937     /**
938      * Method writeSubClassLevel1.
939      * 
940      * @param subClassLevel1 a subClassLevel1 object.
941      * @param serializer a serializer object.
942      * @param tagName a tagName object.
943      * @throws java.io.IOException java.io.IOException if any.
944      * @throws XMLStreamException XMLStreamException if any.
945      */
946     private void writeSubClassLevel1( SubClassLevel1 subClassLevel1, String tagName, XMLStreamWriter serializer )
947         throws java.io.IOException, XMLStreamException
948     {
949         if ( subClassLevel1 != null )
950         {
951             serializer.writeStartElement( tagName );
952             if ( subClassLevel1.getSubAttribute1() != 0L )
953             {
954                 serializer.writeAttribute( "subAttribute1", String.valueOf( subClassLevel1.getSubAttribute1() ) );
955             }
956             if ( subClassLevel1.getBaseAttribute() != 0 )
957             {
958                 serializer.writeAttribute( "baseAttribute", String.valueOf( subClassLevel1.getBaseAttribute() ) );
959             }
960             if ( subClassLevel1.getSubElement1() != 0L )
961             {
962                 serializer.writeStartElement( "subElement1" );
963                 serializer.writeCharacters( String.valueOf( subClassLevel1.getSubElement1() ) );
964                 serializer.writeEndElement();
965             }
966             if ( subClassLevel1.getBaseElement() != 0 )
967             {
968                 serializer.writeStartElement( "baseElement" );
969                 serializer.writeCharacters( String.valueOf( subClassLevel1.getBaseElement() ) );
970                 serializer.writeEndElement();
971             }
972             serializer.writeEndElement();
973         }
974     } //-- void writeSubClassLevel1( SubClassLevel1, String, XMLStreamWriter )
975 
976     /**
977      * Method writeSubClassLevel2.
978      * 
979      * @param subClassLevel2 a subClassLevel2 object.
980      * @param serializer a serializer object.
981      * @param tagName a tagName object.
982      * @throws java.io.IOException java.io.IOException if any.
983      * @throws XMLStreamException XMLStreamException if any.
984      */
985     private void writeSubClassLevel2( SubClassLevel2 subClassLevel2, String tagName, XMLStreamWriter serializer )
986         throws java.io.IOException, XMLStreamException
987     {
988         if ( subClassLevel2 != null )
989         {
990             serializer.writeStartElement( tagName );
991             if ( subClassLevel2.getSubAttribute2() != 0.0f )
992             {
993                 serializer.writeAttribute( "subAttribute2", String.valueOf( subClassLevel2.getSubAttribute2() ) );
994             }
995             if ( subClassLevel2.getSubAttribute1() != 0L )
996             {
997                 serializer.writeAttribute( "subAttribute1", String.valueOf( subClassLevel2.getSubAttribute1() ) );
998             }
999             if ( subClassLevel2.getBaseAttribute() != 0 )
1000             {
1001                 serializer.writeAttribute( "baseAttribute", String.valueOf( subClassLevel2.getBaseAttribute() ) );
1002             }
1003             if ( subClassLevel2.getSubElement2() != 0.0f )
1004             {
1005                 serializer.writeStartElement( "subElement2" );
1006                 serializer.writeCharacters( String.valueOf( subClassLevel2.getSubElement2() ) );
1007                 serializer.writeEndElement();
1008             }
1009             if ( subClassLevel2.getSubElement1() != 0L )
1010             {
1011                 serializer.writeStartElement( "subElement1" );
1012                 serializer.writeCharacters( String.valueOf( subClassLevel2.getSubElement1() ) );
1013                 serializer.writeEndElement();
1014             }
1015             if ( subClassLevel2.getBaseElement() != 0 )
1016             {
1017                 serializer.writeStartElement( "baseElement" );
1018                 serializer.writeCharacters( String.valueOf( subClassLevel2.getBaseElement() ) );
1019                 serializer.writeEndElement();
1020             }
1021             serializer.writeEndElement();
1022         }
1023     } //-- void writeSubClassLevel2( SubClassLevel2, String, XMLStreamWriter )
1024 
1025     /**
1026      * Method writeSubClassLevel3.
1027      * 
1028      * @param subClassLevel3 a subClassLevel3 object.
1029      * @param serializer a serializer object.
1030      * @param tagName a tagName object.
1031      * @throws java.io.IOException java.io.IOException if any.
1032      * @throws XMLStreamException XMLStreamException if any.
1033      */
1034     private void writeSubClassLevel3( SubClassLevel3 subClassLevel3, String tagName, XMLStreamWriter serializer )
1035         throws java.io.IOException, XMLStreamException
1036     {
1037         if ( subClassLevel3 != null )
1038         {
1039             serializer.writeStartElement( tagName );
1040             if ( subClassLevel3.getSubAttribute3() != 0.0 )
1041             {
1042                 serializer.writeAttribute( "subAttribute3", String.valueOf( subClassLevel3.getSubAttribute3() ) );
1043             }
1044             if ( subClassLevel3.getSubAttribute2() != 0.0f )
1045             {
1046                 serializer.writeAttribute( "subAttribute2", String.valueOf( subClassLevel3.getSubAttribute2() ) );
1047             }
1048             if ( subClassLevel3.getSubAttribute1() != 0L )
1049             {
1050                 serializer.writeAttribute( "subAttribute1", String.valueOf( subClassLevel3.getSubAttribute1() ) );
1051             }
1052             if ( subClassLevel3.getBaseAttribute() != 0 )
1053             {
1054                 serializer.writeAttribute( "baseAttribute", String.valueOf( subClassLevel3.getBaseAttribute() ) );
1055             }
1056             if ( subClassLevel3.getSubElement3() != 0.0 )
1057             {
1058                 serializer.writeStartElement( "subElement3" );
1059                 serializer.writeCharacters( String.valueOf( subClassLevel3.getSubElement3() ) );
1060                 serializer.writeEndElement();
1061             }
1062             if ( subClassLevel3.getSubElement2() != 0.0f )
1063             {
1064                 serializer.writeStartElement( "subElement2" );
1065                 serializer.writeCharacters( String.valueOf( subClassLevel3.getSubElement2() ) );
1066                 serializer.writeEndElement();
1067             }
1068             if ( subClassLevel3.getSubElement1() != 0L )
1069             {
1070                 serializer.writeStartElement( "subElement1" );
1071                 serializer.writeCharacters( String.valueOf( subClassLevel3.getSubElement1() ) );
1072                 serializer.writeEndElement();
1073             }
1074             if ( subClassLevel3.getBaseElement() != 0 )
1075             {
1076                 serializer.writeStartElement( "baseElement" );
1077                 serializer.writeCharacters( String.valueOf( subClassLevel3.getBaseElement() ) );
1078                 serializer.writeEndElement();
1079             }
1080             serializer.writeEndElement();
1081         }
1082     } //-- void writeSubClassLevel3( SubClassLevel3, String, XMLStreamWriter )
1083 
1084     /**
1085      * Method writeSuperThing.
1086      * 
1087      * @param superThing a superThing object.
1088      * @param serializer a serializer object.
1089      * @param tagName a tagName object.
1090      * @throws java.io.IOException java.io.IOException if any.
1091      * @throws XMLStreamException XMLStreamException if any.
1092      */
1093     private void writeSuperThing( SuperThing superThing, String tagName, XMLStreamWriter serializer )
1094         throws java.io.IOException, XMLStreamException
1095     {
1096         if ( superThing != null )
1097         {
1098             serializer.writeStartElement( tagName );
1099             serializer.writeEndElement();
1100         }
1101     } //-- void writeSuperThing( SuperThing, String, XMLStreamWriter )
1102 
1103     /**
1104      * Method writeThing.
1105      * 
1106      * @param thing a thing object.
1107      * @param serializer a serializer object.
1108      * @param tagName a tagName object.
1109      * @throws java.io.IOException java.io.IOException if any.
1110      * @throws XMLStreamException XMLStreamException if any.
1111      */
1112     private void writeThing( Thing thing, String tagName, XMLStreamWriter serializer )
1113         throws java.io.IOException, XMLStreamException
1114     {
1115         if ( thing != null )
1116         {
1117             serializer.writeStartElement( tagName );
1118             if ( thing.isSomeBoolean() != false )
1119             {
1120                 serializer.writeStartElement( "someBoolean" );
1121                 serializer.writeCharacters( String.valueOf( thing.isSomeBoolean() ) );
1122                 serializer.writeEndElement();
1123             }
1124             if ( thing.getSomeChar() != '\0' )
1125             {
1126                 serializer.writeStartElement( "someChar" );
1127                 serializer.writeCharacters( String.valueOf( thing.getSomeChar() ) );
1128                 serializer.writeEndElement();
1129             }
1130             if ( thing.getSomeByte() != 0 )
1131             {
1132                 serializer.writeStartElement( "someByte" );
1133                 serializer.writeCharacters( String.valueOf( thing.getSomeByte() ) );
1134                 serializer.writeEndElement();
1135             }
1136             if ( thing.getSomeShort() != 0 )
1137             {
1138                 serializer.writeStartElement( "someShort" );
1139                 serializer.writeCharacters( String.valueOf( thing.getSomeShort() ) );
1140                 serializer.writeEndElement();
1141             }
1142             if ( thing.getSomeInt() != 0 )
1143             {
1144                 serializer.writeStartElement( "someInt" );
1145                 serializer.writeCharacters( String.valueOf( thing.getSomeInt() ) );
1146                 serializer.writeEndElement();
1147             }
1148             if ( thing.getSomeLong() != 0L )
1149             {
1150                 serializer.writeStartElement( "someLong" );
1151                 serializer.writeCharacters( String.valueOf( thing.getSomeLong() ) );
1152                 serializer.writeEndElement();
1153             }
1154             if ( thing.getSomeFloat() != 0.0f )
1155             {
1156                 serializer.writeStartElement( "someFloat" );
1157                 serializer.writeCharacters( String.valueOf( thing.getSomeFloat() ) );
1158                 serializer.writeEndElement();
1159             }
1160             if ( thing.getSomeDouble() != 0.0 )
1161             {
1162                 serializer.writeStartElement( "someDouble" );
1163                 serializer.writeCharacters( String.valueOf( thing.getSomeDouble() ) );
1164                 serializer.writeEndElement();
1165             }
1166             if ( thing.getSomeString() != null )
1167             {
1168                 serializer.writeStartElement( "someString" );
1169                 serializer.writeCharacters( thing.getSomeString() );
1170                 serializer.writeEndElement();
1171             }
1172             if ( thing.getSomeDate() != null )
1173             {
1174                 serializer.writeStartElement( "someDate" );
1175                 serializer.writeCharacters( new java.text.SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ss.SSS", java.util.Locale.US ).format( thing.getSomeDate() ) );
1176                 serializer.writeEndElement();
1177             }
1178             if ( thing.getSomeDom() != null )
1179             {
1180                 writeDom( (Xpp3Dom) thing.getSomeDom(), serializer );
1181             }
1182             if ( ( thing.getSomeProperties() != null ) && ( thing.getSomeProperties().size() > 0 ) )
1183             {
1184                 serializer.writeStartElement( "someProperties" );
1185                 for ( Iterator iter = thing.getSomeProperties().keySet().iterator(); iter.hasNext(); )
1186                 {
1187                     String key = (String) iter.next();
1188                     String value = (String) thing.getSomeProperties().get( key );
1189                     serializer.writeStartElement( "" + key + "" );
1190                     serializer.writeCharacters( value );
1191                     serializer.writeEndElement();
1192                 }
1193                 serializer.writeEndElement();
1194             }
1195             if ( ( thing.getSomeStringList() != null ) && ( thing.getSomeStringList().size() > 0 ) )
1196             {
1197                 serializer.writeStartElement( "someStringList" );
1198                 for ( Iterator iter = thing.getSomeStringList().iterator(); iter.hasNext(); )
1199                 {
1200                     String someStringList = (String) iter.next();
1201                     serializer.writeStartElement( "someStringList" );
1202                     serializer.writeCharacters( someStringList );
1203                     serializer.writeEndElement();
1204                 }
1205                 serializer.writeEndElement();
1206             }
1207             if ( ( thing.getSomeStringSet() != null ) && ( thing.getSomeStringSet().size() > 0 ) )
1208             {
1209                 serializer.writeStartElement( "someStringSet" );
1210                 for ( Iterator iter = thing.getSomeStringSet().iterator(); iter.hasNext(); )
1211                 {
1212                     String someStringSet = (String) iter.next();
1213                     serializer.writeStartElement( "someStringSet" );
1214                     serializer.writeCharacters( someStringSet );
1215                     serializer.writeEndElement();
1216                 }
1217                 serializer.writeEndElement();
1218             }
1219             if ( thing.getDeepThingy() != null )
1220             {
1221                 writeThingy( (Thingy) thing.getDeepThingy(), "deepThingy", serializer );
1222             }
1223             if ( ( thing.getDeepThingyList() != null ) && ( thing.getDeepThingyList().size() > 0 ) )
1224             {
1225                 serializer.writeStartElement( "deepThingyList" );
1226                 for ( Iterator iter = thing.getDeepThingyList().iterator(); iter.hasNext(); )
1227                 {
1228                     Thingyref="../../../../../../../org/codehaus/modello/test/features/Thingy.html#Thingy">Thingy o = (Thingy) iter.next();
1229                     writeThingy( o, "deepThingyList", serializer );
1230                 }
1231                 serializer.writeEndElement();
1232             }
1233             if ( ( thing.getDeepThingySet() != null ) && ( thing.getDeepThingySet().size() > 0 ) )
1234             {
1235                 serializer.writeStartElement( "deepThingySet" );
1236                 for ( Iterator iter = thing.getDeepThingySet().iterator(); iter.hasNext(); )
1237                 {
1238                     Thingyref="../../../../../../../org/codehaus/modello/test/features/Thingy.html#Thingy">Thingy o = (Thingy) iter.next();
1239                     writeThingy( o, "deepThingySet", serializer );
1240                 }
1241                 serializer.writeEndElement();
1242             }
1243             if ( thing.getShallowThingy() != null )
1244             {
1245                 writeThingy( (Thingy) thing.getShallowThingy(), "shallowThingy", serializer );
1246             }
1247             if ( ( thing.getShallowThingyList() != null ) && ( thing.getShallowThingyList().size() > 0 ) )
1248             {
1249                 serializer.writeStartElement( "shallowThingyList" );
1250                 for ( Iterator iter = thing.getShallowThingyList().iterator(); iter.hasNext(); )
1251                 {
1252                     Thingyref="../../../../../../../org/codehaus/modello/test/features/Thingy.html#Thingy">Thingy o = (Thingy) iter.next();
1253                     writeThingy( o, "shallowThingyList", serializer );
1254                 }
1255                 serializer.writeEndElement();
1256             }
1257             if ( ( thing.getShallowThingySet() != null ) && ( thing.getShallowThingySet().size() > 0 ) )
1258             {
1259                 serializer.writeStartElement( "shallowThingySet" );
1260                 for ( Iterator iter = thing.getShallowThingySet().iterator(); iter.hasNext(); )
1261                 {
1262                     Thingyref="../../../../../../../org/codehaus/modello/test/features/Thingy.html#Thingy">Thingy o = (Thingy) iter.next();
1263                     writeThingy( o, "shallowThingySet", serializer );
1264                 }
1265                 serializer.writeEndElement();
1266             }
1267             serializer.writeEndElement();
1268         }
1269     } //-- void writeThing( Thing, String, XMLStreamWriter )
1270 
1271     /**
1272      * Method writeThingy.
1273      * 
1274      * @param thingy a thingy object.
1275      * @param serializer a serializer object.
1276      * @param tagName a tagName object.
1277      * @throws java.io.IOException java.io.IOException if any.
1278      * @throws XMLStreamException XMLStreamException if any.
1279      */
1280     private void writeThingy( Thingy thingy, String tagName, XMLStreamWriter serializer )
1281         throws java.io.IOException, XMLStreamException
1282     {
1283         if ( thingy != null )
1284         {
1285             serializer.writeStartElement( tagName );
1286             serializer.writeCharacters( thingy.getSomeContent() );
1287             serializer.writeEndElement();
1288         }
1289     } //-- void writeThingy( Thingy, String, XMLStreamWriter )
1290 
1291     /**
1292      * Method writeXdocFeatures.
1293      * 
1294      * @param xdocFeatures a xdocFeatures object.
1295      * @param serializer a serializer object.
1296      * @param tagName a tagName object.
1297      * @throws java.io.IOException java.io.IOException if any.
1298      * @throws XMLStreamException XMLStreamException if any.
1299      */
1300     private void writeXdocFeatures( XdocFeatures xdocFeatures, String tagName, XMLStreamWriter serializer )
1301         throws java.io.IOException, XMLStreamException
1302     {
1303         if ( xdocFeatures != null )
1304         {
1305             serializer.writeStartElement( tagName );
1306             if ( xdocFeatures.getField() != null )
1307             {
1308                 serializer.writeStartElement( "field" );
1309                 serializer.writeCharacters( xdocFeatures.getField() );
1310                 serializer.writeEndElement();
1311             }
1312             if ( xdocFeatures.getXdocSeparatorNone() != null )
1313             {
1314                 serializer.writeStartElement( "xdocSeparatorNone" );
1315                 serializer.writeCharacters( xdocFeatures.getXdocSeparatorNone() );
1316                 serializer.writeEndElement();
1317             }
1318             if ( xdocFeatures.getXdocSeparatorBlank() != null )
1319             {
1320                 serializer.writeStartElement( "xdocSeparatorBlank" );
1321                 serializer.writeCharacters( xdocFeatures.getXdocSeparatorBlank() );
1322                 serializer.writeEndElement();
1323             }
1324             serializer.writeEndElement();
1325         }
1326     } //-- void writeXdocFeatures( XdocFeatures, String, XMLStreamWriter )
1327 
1328     /**
1329      * Method writeXmlAttributes.
1330      * 
1331      * @param xmlAttributes a xmlAttributes object.
1332      * @param serializer a serializer object.
1333      * @param tagName a tagName object.
1334      * @throws java.io.IOException java.io.IOException if any.
1335      * @throws XMLStreamException XMLStreamException if any.
1336      */
1337     private void writeXmlAttributes( XmlAttributes xmlAttributes, String tagName, XMLStreamWriter serializer )
1338         throws java.io.IOException, XMLStreamException
1339     {
1340         if ( xmlAttributes != null )
1341         {
1342             serializer.writeStartElement( tagName );
1343             if ( xmlAttributes.isPrimitiveBoolean() != true )
1344             {
1345                 serializer.writeAttribute( "primitiveBoolean", String.valueOf( xmlAttributes.isPrimitiveBoolean() ) );
1346             }
1347             if ( xmlAttributes.getPrimitiveChar() != 'H' )
1348             {
1349                 serializer.writeAttribute( "primitiveChar", String.valueOf( xmlAttributes.getPrimitiveChar() ) );
1350             }
1351             if ( xmlAttributes.getPrimitiveByte() != 12 )
1352             {
1353                 serializer.writeAttribute( "primitiveByte", String.valueOf( xmlAttributes.getPrimitiveByte() ) );
1354             }
1355             if ( xmlAttributes.getPrimitiveShort() != 1212 )
1356             {
1357                 serializer.writeAttribute( "primitiveShort", String.valueOf( xmlAttributes.getPrimitiveShort() ) );
1358             }
1359             if ( xmlAttributes.getPrimitiveInt() != 121212 )
1360             {
1361                 serializer.writeAttribute( "primitiveInt", String.valueOf( xmlAttributes.getPrimitiveInt() ) );
1362             }
1363             if ( xmlAttributes.getPrimitiveLong() != 1234567890123L )
1364             {
1365                 serializer.writeAttribute( "primitiveLong", String.valueOf( xmlAttributes.getPrimitiveLong() ) );
1366             }
1367             if ( xmlAttributes.getPrimitiveFloat() != 12.12f )
1368             {
1369                 serializer.writeAttribute( "primitiveFloat", String.valueOf( xmlAttributes.getPrimitiveFloat() ) );
1370             }
1371             if ( xmlAttributes.getPrimitiveDouble() != 12.12 )
1372             {
1373                 serializer.writeAttribute( "primitiveDouble", String.valueOf( xmlAttributes.getPrimitiveDouble() ) );
1374             }
1375             if ( ( xmlAttributes.getObjectString() != null ) && !xmlAttributes.getObjectString().equals( "default value" ) )
1376             {
1377                 serializer.writeAttribute( "objectString", xmlAttributes.getObjectString() );
1378             }
1379             if ( xmlAttributes.getObjectDate() != null )
1380             {
1381                 serializer.writeAttribute( "objectDate", new java.text.SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ss.SSS", java.util.Locale.US ).format( xmlAttributes.getObjectDate() ) );
1382             }
1383             if ( ( xmlAttributes.getAttribute() != null ) && !xmlAttributes.getAttribute().equals( "default" ) )
1384             {
1385                 serializer.writeAttribute( "tag-name", xmlAttributes.getAttribute() );
1386             }
1387             serializer.writeEndElement();
1388         }
1389     } //-- void writeXmlAttributes( XmlAttributes, String, XMLStreamWriter )
1390 
1391     /**
1392      * Method writeXmlContent.
1393      * 
1394      * @param xmlContent a xmlContent object.
1395      * @param serializer a serializer object.
1396      * @param tagName a tagName object.
1397      * @throws java.io.IOException java.io.IOException if any.
1398      * @throws XMLStreamException XMLStreamException if any.
1399      */
1400     private void writeXmlContent( XmlContent xmlContent, String tagName, XMLStreamWriter serializer )
1401         throws java.io.IOException, XMLStreamException
1402     {
1403         if ( xmlContent != null )
1404         {
1405             serializer.writeStartElement( tagName );
1406             if ( xmlContent.getLongContent() != null )
1407             {
1408                 writeXmlContentLong( (XmlContentLong) xmlContent.getLongContent(), "content.long", serializer );
1409             }
1410             if ( xmlContent.getLongContentWithAttributes() != null )
1411             {
1412                 writeXmlContentLongWithAttributes( (XmlContentLongWithAttributes) xmlContent.getLongContentWithAttributes(), "content.long-with-attributes", serializer );
1413             }
1414             serializer.writeEndElement();
1415         }
1416     } //-- void writeXmlContent( XmlContent, String, XMLStreamWriter )
1417 
1418     /**
1419      * Method writeXmlContentLong.
1420      * 
1421      * @param xmlContentLong a xmlContentLong object.
1422      * @param serializer a serializer object.
1423      * @param tagName a tagName object.
1424      * @throws java.io.IOException java.io.IOException if any.
1425      * @throws XMLStreamException XMLStreamException if any.
1426      */
1427     private void writeXmlContentLong( XmlContentLong xmlContentLong, String tagName, XMLStreamWriter serializer )
1428         throws java.io.IOException, XMLStreamException
1429     {
1430         if ( xmlContentLong != null )
1431         {
1432             serializer.writeStartElement( tagName );
1433             serializer.writeCharacters( String.valueOf( xmlContentLong.getContent() ) );
1434             serializer.writeEndElement();
1435         }
1436     } //-- void writeXmlContentLong( XmlContentLong, String, XMLStreamWriter )
1437 
1438     /**
1439      * Method writeXmlContentLongWithAttributes.
1440      * 
1441      * @param xmlContentLongWithAttributes a
1442      * xmlContentLongWithAttributes object.
1443      * @param serializer a serializer object.
1444      * @param tagName a tagName object.
1445      * @throws java.io.IOException java.io.IOException if any.
1446      * @throws XMLStreamException XMLStreamException if any.
1447      */
1448     private void writeXmlContentLongWithAttributes( XmlContentLongWithAttributes xmlContentLongWithAttributes, String tagName, XMLStreamWriter serializer )
1449         throws java.io.IOException, XMLStreamException
1450     {
1451         if ( xmlContentLongWithAttributes != null )
1452         {
1453             serializer.writeStartElement( tagName );
1454             if ( xmlContentLongWithAttributes.getAttr() != null )
1455             {
1456                 serializer.writeAttribute( "attr", xmlContentLongWithAttributes.getAttr() );
1457             }
1458             if ( xmlContentLongWithAttributes.getAttr2() != 0 )
1459             {
1460                 serializer.writeAttribute( "attr2", String.valueOf( xmlContentLongWithAttributes.getAttr2() ) );
1461             }
1462             serializer.writeCharacters( String.valueOf( xmlContentLongWithAttributes.getContent() ) );
1463             serializer.writeEndElement();
1464         }
1465     } //-- void writeXmlContentLongWithAttributes( XmlContentLongWithAttributes, String, XMLStreamWriter )
1466 
1467     /**
1468      * Method writeXmlFeatures.
1469      * 
1470      * @param xmlFeatures a xmlFeatures object.
1471      * @param serializer a serializer object.
1472      * @param tagName a tagName object.
1473      * @throws java.io.IOException java.io.IOException if any.
1474      * @throws XMLStreamException XMLStreamException if any.
1475      */
1476     private void writeXmlFeatures( XmlFeatures xmlFeatures, String tagName, XMLStreamWriter serializer )
1477         throws java.io.IOException, XMLStreamException
1478     {
1479         if ( xmlFeatures != null )
1480         {
1481             serializer.writeStartElement( tagName );
1482             if ( xmlFeatures.getFieldNameAttribute() != null )
1483             {
1484                 serializer.writeAttribute( "tag-name.attribute", xmlFeatures.getFieldNameAttribute() );
1485             }
1486             if ( xmlFeatures.getAttributes() != null )
1487             {
1488                 writeXmlAttributes( (XmlAttributes) xmlFeatures.getAttributes(), "attributes", serializer );
1489             }
1490             if ( xmlFeatures.getAttributesDefault() != null )
1491             {
1492                 writeXmlAttributes( (XmlAttributes) xmlFeatures.getAttributesDefault(), "attributesDefault", serializer );
1493             }
1494             if ( xmlFeatures.getContent() != null )
1495             {
1496                 writeXmlContent( (XmlContent) xmlFeatures.getContent(), "content", serializer );
1497             }
1498             if ( xmlFeatures.getFieldTrim() != null )
1499             {
1500                 serializer.writeStartElement( "fieldTrim" );
1501                 serializer.writeCharacters( xmlFeatures.getFieldTrim() );
1502                 serializer.writeEndElement();
1503             }
1504             if ( xmlFeatures.getFieldNoTrim() != null )
1505             {
1506                 serializer.writeStartElement( "fieldNoTrim" );
1507                 serializer.writeCharacters( xmlFeatures.getFieldNoTrim() );
1508                 serializer.writeEndElement();
1509             }
1510             if ( xmlFeatures.getDom() != null )
1511             {
1512                 writeDom( (Xpp3Dom) xmlFeatures.getDom(), serializer );
1513             }
1514             if ( xmlFeatures.getDomNoTrim() != null )
1515             {
1516                 writeDom( (Xpp3Dom) xmlFeatures.getDomNoTrim(), serializer );
1517             }
1518             if ( xmlFeatures.getFieldName() != null )
1519             {
1520                 serializer.writeStartElement( "tag-name" );
1521                 serializer.writeCharacters( xmlFeatures.getFieldName() );
1522                 serializer.writeEndElement();
1523             }
1524             if ( xmlFeatures.getDateXmlFormat() != null )
1525             {
1526                 serializer.writeStartElement( "dateXmlFormat" );
1527                 serializer.writeCharacters( new java.text.SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ss", java.util.Locale.US ).format( xmlFeatures.getDateXmlFormat() ) );
1528                 serializer.writeEndElement();
1529             }
1530             if ( xmlFeatures.getDateLong() != null )
1531             {
1532                 serializer.writeStartElement( "dateLong" );
1533                 serializer.writeCharacters( String.valueOf( xmlFeatures.getDateLong().getTime() ) );
1534                 serializer.writeEndElement();
1535             }
1536             if ( ( xmlFeatures.getXmlItemsStyleFlats() != null ) && ( xmlFeatures.getXmlItemsStyleFlats().size() > 0 ) )
1537             {
1538                 for ( Iterator iter = xmlFeatures.getXmlItemsStyleFlats().iterator(); iter.hasNext(); )
1539                 {
1540                     Reference="../../../../../../../org/codehaus/modello/test/features/Reference.html#Reference">Reference o = (Reference) iter.next();
1541                     writeReference( o, "xmlItemsStyleFlat", serializer );
1542                 }
1543             }
1544             if ( ( xmlFeatures.getXmlAssociationTagNames() != null ) && ( xmlFeatures.getXmlAssociationTagNames().size() > 0 ) )
1545             {
1546                 serializer.writeStartElement( "xmlAssociationTagNames" );
1547                 for ( Iterator iter = xmlFeatures.getXmlAssociationTagNames().iterator(); iter.hasNext(); )
1548                 {
1549                     Reference="../../../../../../../org/codehaus/modello/test/features/Reference.html#Reference">Reference o = (Reference) iter.next();
1550                     writeReference( o, "association.tag-name", serializer );
1551                 }
1552                 serializer.writeEndElement();
1553             }
1554             if ( ( xmlFeatures.getXmlTagNameAssociation() != null ) && ( xmlFeatures.getXmlTagNameAssociation().size() > 0 ) )
1555             {
1556                 serializer.writeStartElement( "field.tag-names" );
1557                 for ( Iterator iter = xmlFeatures.getXmlTagNameAssociation().iterator(); iter.hasNext(); )
1558                 {
1559                     Reference="../../../../../../../org/codehaus/modello/test/features/Reference.html#Reference">Reference o = (Reference) iter.next();
1560                     writeReference( o, "field.tag-name", serializer );
1561                 }
1562                 serializer.writeEndElement();
1563             }
1564             if ( ( xmlFeatures.getXmlTagNameAssociationTagNames() != null ) && ( xmlFeatures.getXmlTagNameAssociationTagNames().size() > 0 ) )
1565             {
1566                 serializer.writeStartElement( "field.tag-name" );
1567                 for ( Iterator iter = xmlFeatures.getXmlTagNameAssociationTagNames().iterator(); iter.hasNext(); )
1568                 {
1569                     Reference="../../../../../../../org/codehaus/modello/test/features/Reference.html#Reference">Reference o = (Reference) iter.next();
1570                     writeReference( o, "association.tag-name", serializer );
1571                 }
1572                 serializer.writeEndElement();
1573             }
1574             if ( ( xmlFeatures.getXmlFlatAssociationTagNames() != null ) && ( xmlFeatures.getXmlFlatAssociationTagNames().size() > 0 ) )
1575             {
1576                 for ( Iterator iter = xmlFeatures.getXmlFlatAssociationTagNames().iterator(); iter.hasNext(); )
1577                 {
1578                     Reference="../../../../../../../org/codehaus/modello/test/features/Reference.html#Reference">Reference o = (Reference) iter.next();
1579                     writeReference( o, "association.tag-name", serializer );
1580                 }
1581             }
1582             if ( ( xmlFeatures.getExplodeProperties() != null ) && ( xmlFeatures.getExplodeProperties().size() > 0 ) )
1583             {
1584                 serializer.writeStartElement( "explodeProperties" );
1585                 for ( Iterator iter = xmlFeatures.getExplodeProperties().keySet().iterator(); iter.hasNext(); )
1586                 {
1587                     String key = (String) iter.next();
1588                     String value = (String) xmlFeatures.getExplodeProperties().get( key );
1589                     serializer.writeStartElement( "explodeProperty" );
1590                     serializer.writeStartElement( "key" );
1591                     serializer.writeCharacters( key );
1592                     serializer.writeEndElement();
1593                     serializer.writeStartElement( "value" );
1594                     serializer.writeCharacters( value );
1595                     serializer.writeEndElement();
1596                     serializer.writeEndElement();
1597                 }
1598                 serializer.writeEndElement();
1599             }
1600             if ( ( xmlFeatures.getInlineProperties() != null ) && ( xmlFeatures.getInlineProperties().size() > 0 ) )
1601             {
1602                 serializer.writeStartElement( "inlineProperties" );
1603                 for ( Iterator iter = xmlFeatures.getInlineProperties().keySet().iterator(); iter.hasNext(); )
1604                 {
1605                     String key = (String) iter.next();
1606                     String value = (String) xmlFeatures.getInlineProperties().get( key );
1607                     serializer.writeStartElement( "" + key + "" );
1608                     serializer.writeCharacters( value );
1609                     serializer.writeEndElement();
1610                 }
1611                 serializer.writeEndElement();
1612             }
1613             if ( xmlFeatures.getXmlTransientFields() != null )
1614             {
1615                 writeXmlTransientFields( (XmlTransientFields) xmlFeatures.getXmlTransientFields(), "xmlTransientFields", serializer );
1616             }
1617             if ( xmlFeatures.getXmlFieldsOrder() != null )
1618             {
1619                 writeXmlFieldsOrder( (XmlFieldsOrder) xmlFeatures.getXmlFieldsOrder(), "xmlFieldsOrder", serializer );
1620             }
1621             if ( xmlFeatures.getXsdFeatures() != null )
1622             {
1623                 writeXsdFeatures( (XsdFeatures) xmlFeatures.getXsdFeatures(), "xsdFeatures", serializer );
1624             }
1625             serializer.writeEndElement();
1626         }
1627     } //-- void writeXmlFeatures( XmlFeatures, String, XMLStreamWriter )
1628 
1629     /**
1630      * Method writeXmlFieldsOrder.
1631      * 
1632      * @param xmlFieldsOrder a xmlFieldsOrder object.
1633      * @param serializer a serializer object.
1634      * @param tagName a tagName object.
1635      * @throws java.io.IOException java.io.IOException if any.
1636      * @throws XMLStreamException XMLStreamException if any.
1637      */
1638     private void writeXmlFieldsOrder( XmlFieldsOrder xmlFieldsOrder, String tagName, XMLStreamWriter serializer )
1639         throws java.io.IOException, XMLStreamException
1640     {
1641         if ( xmlFieldsOrder != null )
1642         {
1643             serializer.writeStartElement( tagName );
1644             if ( xmlFieldsOrder.getField1() != null )
1645             {
1646                 serializer.writeStartElement( "field1" );
1647                 serializer.writeCharacters( xmlFieldsOrder.getField1() );
1648                 serializer.writeEndElement();
1649             }
1650             if ( xmlFieldsOrder.getField() != null )
1651             {
1652                 serializer.writeStartElement( "field-2" );
1653                 serializer.writeCharacters( xmlFieldsOrder.getField() );
1654                 serializer.writeEndElement();
1655             }
1656             if ( xmlFieldsOrder.getField3() != null )
1657             {
1658                 serializer.writeStartElement( "field3" );
1659                 serializer.writeCharacters( xmlFieldsOrder.getField3() );
1660                 serializer.writeEndElement();
1661             }
1662             if ( xmlFieldsOrder.getField4() != null )
1663             {
1664                 serializer.writeStartElement( "field4" );
1665                 serializer.writeCharacters( xmlFieldsOrder.getField4() );
1666                 serializer.writeEndElement();
1667             }
1668             if ( xmlFieldsOrder.getField5() != null )
1669             {
1670                 serializer.writeStartElement( "field5" );
1671                 serializer.writeCharacters( xmlFieldsOrder.getField5() );
1672                 serializer.writeEndElement();
1673             }
1674             if ( xmlFieldsOrder.getField6() != null )
1675             {
1676                 serializer.writeStartElement( "field6" );
1677                 serializer.writeCharacters( xmlFieldsOrder.getField6() );
1678                 serializer.writeEndElement();
1679             }
1680             if ( xmlFieldsOrder.getField7() != null )
1681             {
1682                 serializer.writeStartElement( "field7" );
1683                 serializer.writeCharacters( xmlFieldsOrder.getField7() );
1684                 serializer.writeEndElement();
1685             }
1686             serializer.writeEndElement();
1687         }
1688     } //-- void writeXmlFieldsOrder( XmlFieldsOrder, String, XMLStreamWriter )
1689 
1690     /**
1691      * Method writeXmlFieldsOrderParent.
1692      * 
1693      * @param xmlFieldsOrderParent a xmlFieldsOrderParent object.
1694      * @param serializer a serializer object.
1695      * @param tagName a tagName object.
1696      * @throws java.io.IOException java.io.IOException if any.
1697      * @throws XMLStreamException XMLStreamException if any.
1698      */
1699     private void writeXmlFieldsOrderParent( XmlFieldsOrderParent xmlFieldsOrderParent, String tagName, XMLStreamWriter serializer )
1700         throws java.io.IOException, XMLStreamException
1701     {
1702         if ( xmlFieldsOrderParent != null )
1703         {
1704             serializer.writeStartElement( tagName );
1705             if ( xmlFieldsOrderParent.getField() != null )
1706             {
1707                 serializer.writeStartElement( "field-2" );
1708                 serializer.writeCharacters( xmlFieldsOrderParent.getField() );
1709                 serializer.writeEndElement();
1710             }
1711             if ( xmlFieldsOrderParent.getField4() != null )
1712             {
1713                 serializer.writeStartElement( "field4" );
1714                 serializer.writeCharacters( xmlFieldsOrderParent.getField4() );
1715                 serializer.writeEndElement();
1716             }
1717             if ( xmlFieldsOrderParent.getField5() != null )
1718             {
1719                 serializer.writeStartElement( "field5" );
1720                 serializer.writeCharacters( xmlFieldsOrderParent.getField5() );
1721                 serializer.writeEndElement();
1722             }
1723             if ( xmlFieldsOrderParent.getField7() != null )
1724             {
1725                 serializer.writeStartElement( "field7" );
1726                 serializer.writeCharacters( xmlFieldsOrderParent.getField7() );
1727                 serializer.writeEndElement();
1728             }
1729             serializer.writeEndElement();
1730         }
1731     } //-- void writeXmlFieldsOrderParent( XmlFieldsOrderParent, String, XMLStreamWriter )
1732 
1733     /**
1734      * Method writeXmlFieldsOrderParent2.
1735      * 
1736      * @param xmlFieldsOrderParent2 a xmlFieldsOrderParent2 object.
1737      * @param serializer a serializer object.
1738      * @param tagName a tagName object.
1739      * @throws java.io.IOException java.io.IOException if any.
1740      * @throws XMLStreamException XMLStreamException if any.
1741      */
1742     private void writeXmlFieldsOrderParent2( XmlFieldsOrderParent2 xmlFieldsOrderParent2, String tagName, XMLStreamWriter serializer )
1743         throws java.io.IOException, XMLStreamException
1744     {
1745         if ( xmlFieldsOrderParent2 != null )
1746         {
1747             serializer.writeStartElement( tagName );
1748             if ( xmlFieldsOrderParent2.getField() != null )
1749             {
1750                 serializer.writeStartElement( "field-2" );
1751                 serializer.writeCharacters( xmlFieldsOrderParent2.getField() );
1752                 serializer.writeEndElement();
1753             }
1754             serializer.writeEndElement();
1755         }
1756     } //-- void writeXmlFieldsOrderParent2( XmlFieldsOrderParent2, String, XMLStreamWriter )
1757 
1758     /**
1759      * Method writeXmlTransientFields.
1760      * 
1761      * @param xmlTransientFields a xmlTransientFields object.
1762      * @param serializer a serializer object.
1763      * @param tagName a tagName object.
1764      * @throws java.io.IOException java.io.IOException if any.
1765      * @throws XMLStreamException XMLStreamException if any.
1766      */
1767     private void writeXmlTransientFields( XmlTransientFields xmlTransientFields, String tagName, XMLStreamWriter serializer )
1768         throws java.io.IOException, XMLStreamException
1769     {
1770         if ( xmlTransientFields != null )
1771         {
1772             serializer.writeStartElement( tagName );
1773             if ( xmlTransientFields.getPersistentField() != null )
1774             {
1775                 serializer.writeStartElement( "persistentField" );
1776                 serializer.writeCharacters( xmlTransientFields.getPersistentField() );
1777                 serializer.writeEndElement();
1778             }
1779             serializer.writeEndElement();
1780         }
1781     } //-- void writeXmlTransientFields( XmlTransientFields, String, XMLStreamWriter )
1782 
1783     /**
1784      * Method writeXsdFeatures.
1785      * 
1786      * @param xsdFeatures a xsdFeatures object.
1787      * @param serializer a serializer object.
1788      * @param tagName a tagName object.
1789      * @throws java.io.IOException java.io.IOException if any.
1790      * @throws XMLStreamException XMLStreamException if any.
1791      */
1792     private void writeXsdFeatures( XsdFeatures xsdFeatures, String tagName, XMLStreamWriter serializer )
1793         throws java.io.IOException, XMLStreamException
1794     {
1795         if ( xsdFeatures != null )
1796         {
1797             serializer.writeStartElement( tagName );
1798             if ( xsdFeatures.getAttribute() != null )
1799             {
1800                 serializer.writeAttribute( "attribute", xsdFeatures.getAttribute() );
1801             }
1802             serializer.writeEndElement();
1803         }
1804     } //-- void writeXsdFeatures( XsdFeatures, String, XMLStreamWriter )
1805 
1806 }