1
2
3
4
5
6
7
8 package org.apache.maven.continuum.model.project.io.stax;
9
10
11
12
13
14 import java.io.ByteArrayInputStream;
15 import java.io.File;
16 import java.io.FileInputStream;
17 import java.io.IOException;
18 import java.io.InputStreamReader;
19 import java.io.Reader;
20 import java.io.StringReader;
21 import java.io.StringWriter;
22 import java.text.DateFormat;
23 import java.text.ParsePosition;
24 import java.util.Locale;
25 import java.util.regex.Matcher;
26 import java.util.regex.Pattern;
27 import javax.xml.stream.*;
28 import org.apache.continuum.model.project.ProjectScmRoot;
29 import org.apache.continuum.model.release.ContinuumReleaseResult;
30 import org.apache.continuum.model.repository.AbstractPurgeConfiguration;
31 import org.apache.continuum.model.repository.DirectoryPurgeConfiguration;
32 import org.apache.continuum.model.repository.LocalRepository;
33 import org.apache.continuum.model.repository.RepositoryPurgeConfiguration;
34 import org.apache.maven.continuum.model.project.BuildDefinition;
35 import org.apache.maven.continuum.model.project.BuildDefinitionTemplate;
36 import org.apache.maven.continuum.model.project.BuildQueue;
37 import org.apache.maven.continuum.model.project.BuildResult;
38 import org.apache.maven.continuum.model.project.ContinuumDatabase;
39 import org.apache.maven.continuum.model.project.Project;
40 import org.apache.maven.continuum.model.project.ProjectDependency;
41 import org.apache.maven.continuum.model.project.ProjectDeveloper;
42 import org.apache.maven.continuum.model.project.ProjectGroup;
43 import org.apache.maven.continuum.model.project.ProjectNotifier;
44 import org.apache.maven.continuum.model.project.Schedule;
45 import org.apache.maven.continuum.model.scm.ChangeFile;
46 import org.apache.maven.continuum.model.scm.ChangeSet;
47 import org.apache.maven.continuum.model.scm.ScmResult;
48 import org.apache.maven.continuum.model.system.Installation;
49 import org.apache.maven.continuum.model.system.NotificationAddress;
50 import org.apache.maven.continuum.model.system.Profile;
51 import org.apache.maven.continuum.model.system.SystemConfiguration;
52 import org.apache.maven.continuum.project.ContinuumProjectState;
53 import org.codehaus.plexus.util.xml.Xpp3Dom;
54
55
56
57
58
59
60 @SuppressWarnings( "all" )
61 public class ContinuumStaxReader
62 {
63
64
65
66
67
68
69
70
71 private java.util.Map projectGroupInstances;
72
73
74
75
76 private java.util.Map localRepositoryReferences;
77
78
79
80
81 private java.util.Map projectInstances;
82
83
84
85
86 private java.util.Map projectGroupReferences;
87
88
89
90
91 private java.util.Map projectReferences;
92
93
94
95
96 private java.util.Map buildDefinitionReferences;
97
98
99
100
101 private java.util.Map buildDefinitionInstances;
102
103
104
105
106 private java.util.Map scheduleReferences;
107
108
109
110
111 private java.util.Map profileReferences;
112
113
114
115
116 private java.util.Map buildQueueInstances;
117
118
119
120
121 private java.util.Map scheduleInstances;
122
123
124
125
126 private java.util.Map buildQueueReferences;
127
128
129
130
131 private java.util.Map profileInstances;
132
133
134
135
136 private java.util.Map installationReferences;
137
138
139
140
141 private java.util.Map installationInstances;
142
143
144
145
146 private java.util.Map localRepositoryInstances;
147
148
149
150
151
152
153
154
155
156
157
158
159
160 private Xpp3Dom buildDom( XMLStreamReader xmlStreamReader )
161 throws XMLStreamException
162 {
163 java.util.List elements = new java.util.ArrayList();
164 java.util.List values = new java.util.ArrayList();
165 int eventType = xmlStreamReader.getEventType();
166 while ( xmlStreamReader.hasNext() )
167 {
168 if ( eventType == XMLStreamConstants.START_ELEMENT )
169 {
170 String rawName = xmlStreamReader.getLocalName();
171 Xpp3Dom childConfiguration = new Xpp3Dom( rawName );
172 int depth = elements.size();
173 if ( depth > 0 )
174 {
175 Xpp3Dom parent = (Xpp3Dom) elements.get( depth - 1 );
176 parent.addChild( childConfiguration );
177 }
178 elements.add( childConfiguration );
179 if ( xmlStreamReader.isEndElement() )
180 {
181 values.add( null );
182 }
183 else
184 {
185 values.add( new StringBuffer() );
186 }
187 int attributesSize = xmlStreamReader.getAttributeCount();
188 for ( int i = 0; i < attributesSize; i++ )
189 {
190 String name = xmlStreamReader.getAttributeLocalName( i );
191 String value = xmlStreamReader.getAttributeValue( i );
192 childConfiguration.setAttribute( name, value );
193 }
194 }
195 else if ( eventType == XMLStreamConstants.CHARACTERS )
196 {
197 int depth = values.size() - 1;
198 StringBuffer valueBuffer = (StringBuffer) values.get( depth );
199 String text = xmlStreamReader.getText();
200 text = text.trim();
201 valueBuffer.append( text );
202 }
203 else if ( eventType == XMLStreamConstants.END_ELEMENT )
204 {
205 int depth = elements.size() - 1;
206 Xpp3Dom finishedConfiguration = (Xpp3Dom) elements.remove( depth );
207
208 Object accumulatedValue = values.remove( depth );
209 if ( finishedConfiguration.getChildCount() == 0 )
210 {
211 if ( accumulatedValue == null )
212 {
213 finishedConfiguration.setValue( null );
214 }
215 else
216 {
217 finishedConfiguration.setValue( accumulatedValue.toString() );
218 }
219 }
220 if ( depth == 0 )
221 {
222 return finishedConfiguration;
223 }
224 }
225 eventType = xmlStreamReader.next();
226 }
227 throw new IllegalStateException( "End of document found before returning to 0 depth" );
228 }
229
230
231
232
233
234
235
236
237
238
239
240 private boolean checkFieldWithDuplicate( XMLStreamReader xmlStreamReader, String tagName, String alias, java.util.Set parsed )
241 throws XMLStreamException
242 {
243 if ( !( xmlStreamReader.getLocalName().equals( tagName ) || xmlStreamReader.getLocalName().equals( alias ) ) )
244 {
245 return false;
246 }
247 if ( parsed.contains( tagName ) )
248 {
249 throw new XMLStreamException( "Duplicated tag: '" + tagName + "'", xmlStreamReader.getLocation() );
250 }
251 parsed.add( tagName );
252 return true;
253 }
254
255
256
257
258
259
260
261
262
263
264 private boolean getBooleanValue( String s, String attribute, XMLStreamReader xmlStreamReader )
265 throws XMLStreamException
266 {
267 if ( s != null )
268 {
269 return Boolean.valueOf( s ).booleanValue();
270 }
271 return false;
272 }
273
274
275
276
277
278
279
280
281
282
283
284 private byte getByteValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
285 throws XMLStreamException
286 {
287 if ( s != null )
288 {
289 try
290 {
291 return Byte.valueOf( s ).byteValue();
292 }
293 catch ( NumberFormatException e )
294 {
295 if ( strict )
296 {
297 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a byte but was '" + s + "'", xmlStreamReader.getLocation() );
298 }
299 }
300 }
301 return 0;
302 }
303
304
305
306
307
308
309
310
311
312
313 private char getCharacterValue( String s, String attribute, XMLStreamReader xmlStreamReader )
314 throws XMLStreamException
315 {
316 if ( s != null )
317 {
318 return s.charAt( 0 );
319 }
320 return 0;
321 }
322
323
324
325
326
327
328
329
330
331
332
333 private java.util.Date getDateValue( String s, String attribute, String dateFormat, XMLStreamReader xmlStreamReader )
334 throws XMLStreamException
335 {
336 if ( s != null )
337 {
338 String effectiveDateFormat = dateFormat;
339 if ( dateFormat == null )
340 {
341 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
342 }
343 if ( "long".equals( effectiveDateFormat ) )
344 {
345 try
346 {
347 return new java.util.Date( Long.parseLong( s ) );
348 }
349 catch ( NumberFormatException e )
350 {
351 throw new XMLStreamException( e.getMessage() );
352 }
353 }
354 else
355 {
356 try
357 {
358 DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, Locale.US );
359 return dateParser.parse( s );
360 }
361 catch ( java.text.ParseException e )
362 {
363 throw new XMLStreamException( e.getMessage() );
364 }
365 }
366 }
367 return null;
368 }
369
370
371
372
373
374
375
376
377 private String getDefaultValue( String s, String v )
378 {
379 if ( s == null )
380 {
381 s = v;
382 }
383 return s;
384 }
385
386
387
388
389
390
391
392
393
394
395
396 private double getDoubleValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
397 throws XMLStreamException
398 {
399 if ( s != null )
400 {
401 try
402 {
403 return Double.valueOf( s ).doubleValue();
404 }
405 catch ( NumberFormatException e )
406 {
407 if ( strict )
408 {
409 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation() );
410 }
411 }
412 }
413 return 0;
414 }
415
416
417
418
419
420
421
422
423
424
425
426 private float getFloatValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
427 throws XMLStreamException
428 {
429 if ( s != null )
430 {
431 try
432 {
433 return Float.valueOf( s ).floatValue();
434 }
435 catch ( NumberFormatException e )
436 {
437 if ( strict )
438 {
439 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation() );
440 }
441 }
442 }
443 return 0;
444 }
445
446
447
448
449
450
451
452
453
454
455
456 private int getIntegerValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
457 throws XMLStreamException
458 {
459 if ( s != null )
460 {
461 try
462 {
463 return Integer.valueOf( s ).intValue();
464 }
465 catch ( NumberFormatException e )
466 {
467 if ( strict )
468 {
469 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be an integer but was '" + s + "'", xmlStreamReader.getLocation() );
470 }
471 }
472 }
473 return 0;
474 }
475
476
477
478
479
480
481
482
483
484
485
486 private long getLongValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
487 throws XMLStreamException
488 {
489 if ( s != null )
490 {
491 try
492 {
493 return Long.valueOf( s ).longValue();
494 }
495 catch ( NumberFormatException e )
496 {
497 if ( strict )
498 {
499 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a long integer but was '" + s + "'", xmlStreamReader.getLocation() );
500 }
501 }
502 }
503 return 0;
504 }
505
506
507
508
509
510
511
512
513
514
515
516 private String getRequiredAttributeValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
517 throws XMLStreamException
518 {
519 if ( s == null )
520 {
521 if ( strict )
522 {
523 throw new XMLStreamException( "Missing required value for attribute '" + attribute + "'", xmlStreamReader.getLocation() );
524 }
525 }
526 return s;
527 }
528
529
530
531
532
533
534
535
536
537
538
539 private short getShortValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
540 throws XMLStreamException
541 {
542 if ( s != null )
543 {
544 try
545 {
546 return Short.valueOf( s ).shortValue();
547 }
548 catch ( NumberFormatException e )
549 {
550 if ( strict )
551 {
552 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a short integer but was '" + s + "'", xmlStreamReader.getLocation() );
553 }
554 }
555 }
556 return 0;
557 }
558
559
560
561
562
563
564
565 private String getTrimmedValue( String s )
566 {
567 if ( s != null )
568 {
569 s = s.trim();
570 }
571 return s;
572 }
573
574
575
576
577
578
579
580
581
582
583
584
585 private AbstractPurgeConfiguration parseAbstractPurgeConfiguration( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
586 throws IOException, XMLStreamException
587 {
588 AbstractPurgeConfiguration abstractPurgeConfiguration = new AbstractPurgeConfiguration();
589 java.util.Set parsed = new java.util.HashSet();
590 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
591 {
592 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
593 {
594 abstractPurgeConfiguration.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
595 }
596 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
597 {
598 abstractPurgeConfiguration.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
599 }
600 else if ( checkFieldWithDuplicate( xmlStreamReader, "deleteAll", null, parsed ) )
601 {
602 abstractPurgeConfiguration.setDeleteAll( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "deleteAll", xmlStreamReader ) );
603 }
604 else if ( checkFieldWithDuplicate( xmlStreamReader, "retentionCount", null, parsed ) )
605 {
606 abstractPurgeConfiguration.setRetentionCount( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "2" ) ), "retentionCount", xmlStreamReader, strict ) );
607 }
608 else if ( checkFieldWithDuplicate( xmlStreamReader, "daysOlder", null, parsed ) )
609 {
610 abstractPurgeConfiguration.setDaysOlder( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "100" ) ), "daysOlder", xmlStreamReader, strict ) );
611 }
612 else if ( checkFieldWithDuplicate( xmlStreamReader, "enabled", null, parsed ) )
613 {
614 abstractPurgeConfiguration.setEnabled( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "enabled", xmlStreamReader ) );
615 }
616 else if ( checkFieldWithDuplicate( xmlStreamReader, "schedule", null, parsed ) )
617 {
618 String value = xmlStreamReader.getAttributeValue( null, "id" );
619 if ( value != null )
620 {
621
622 if ( scheduleReferences == null )
623 {
624 scheduleReferences = new java.util.HashMap();
625 }
626 java.util.Map refs = (java.util.Map) scheduleReferences.get( abstractPurgeConfiguration );
627 if ( refs == null )
628 {
629 refs = new java.util.HashMap();
630 scheduleReferences.put( abstractPurgeConfiguration, refs );
631 }
632 refs.put( "schedule", value );
633 }
634 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
635 {
636 xmlStreamReader.next();
637 }
638 }
639 else if ( checkFieldWithDuplicate( xmlStreamReader, "defaultPurge", null, parsed ) )
640 {
641 abstractPurgeConfiguration.setDefaultPurge( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "defaultPurge", xmlStreamReader ) );
642 }
643 else
644 {
645 if ( strict )
646 {
647 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
648 }
649 else
650 {
651 int unrecognizedTagCount = 1;
652 while( unrecognizedTagCount != 0 )
653 {
654 xmlStreamReader.next();
655 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
656 {
657 unrecognizedTagCount++;
658 }
659 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
660 {
661 unrecognizedTagCount--;
662 }
663 }
664 }
665 }
666 }
667 return abstractPurgeConfiguration;
668 }
669
670
671
672
673
674
675
676
677
678
679
680
681 private BuildDefinition parseBuildDefinition( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
682 throws IOException, XMLStreamException
683 {
684 BuildDefinition buildDefinition = new BuildDefinition();
685 java.util.Set parsed = new java.util.HashSet();
686 if ( buildDefinitionInstances == null )
687 {
688 buildDefinitionInstances = new java.util.HashMap();
689 }
690 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
691 if ( v != null )
692 {
693 buildDefinitionInstances.put( v, buildDefinition );
694 }
695 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
696 {
697 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
698 {
699 buildDefinition.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
700 }
701 else if ( checkFieldWithDuplicate( xmlStreamReader, "defaultForProject", null, parsed ) )
702 {
703 buildDefinition.setDefaultForProject( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "defaultForProject", xmlStreamReader ) );
704 }
705 else if ( checkFieldWithDuplicate( xmlStreamReader, "goals", null, parsed ) )
706 {
707 buildDefinition.setGoals( getTrimmedValue( xmlStreamReader.getElementText() ) );
708 }
709 else if ( checkFieldWithDuplicate( xmlStreamReader, "arguments", null, parsed ) )
710 {
711 buildDefinition.setArguments( getTrimmedValue( xmlStreamReader.getElementText() ) );
712 }
713 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildFile", null, parsed ) )
714 {
715 buildDefinition.setBuildFile( getTrimmedValue( xmlStreamReader.getElementText() ) );
716 }
717 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildFresh", null, parsed ) )
718 {
719 buildDefinition.setBuildFresh( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "buildFresh", xmlStreamReader ) );
720 }
721 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
722 {
723 buildDefinition.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
724 }
725 else if ( checkFieldWithDuplicate( xmlStreamReader, "type", null, parsed ) )
726 {
727 buildDefinition.setType( getTrimmedValue( xmlStreamReader.getElementText() ) );
728 }
729 else if ( checkFieldWithDuplicate( xmlStreamReader, "schedule", null, parsed ) )
730 {
731 String value = xmlStreamReader.getAttributeValue( null, "id" );
732 if ( value != null )
733 {
734
735 if ( scheduleReferences == null )
736 {
737 scheduleReferences = new java.util.HashMap();
738 }
739 java.util.Map refs = (java.util.Map) scheduleReferences.get( buildDefinition );
740 if ( refs == null )
741 {
742 refs = new java.util.HashMap();
743 scheduleReferences.put( buildDefinition, refs );
744 }
745 refs.put( "schedule", value );
746 }
747 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
748 {
749 xmlStreamReader.next();
750 }
751 }
752 else if ( checkFieldWithDuplicate( xmlStreamReader, "profile", null, parsed ) )
753 {
754 String value = xmlStreamReader.getAttributeValue( null, "id" );
755 if ( value != null )
756 {
757
758 if ( profileReferences == null )
759 {
760 profileReferences = new java.util.HashMap();
761 }
762 java.util.Map refs = (java.util.Map) profileReferences.get( buildDefinition );
763 if ( refs == null )
764 {
765 refs = new java.util.HashMap();
766 profileReferences.put( buildDefinition, refs );
767 }
768 refs.put( "profile", value );
769 }
770 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
771 {
772 xmlStreamReader.next();
773 }
774 }
775 else if ( checkFieldWithDuplicate( xmlStreamReader, "alwaysBuild", null, parsed ) )
776 {
777 buildDefinition.setAlwaysBuild( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "alwaysBuild", xmlStreamReader ) );
778 }
779 else if ( checkFieldWithDuplicate( xmlStreamReader, "template", null, parsed ) )
780 {
781 buildDefinition.setTemplate( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "template", xmlStreamReader ) );
782 }
783 else
784 {
785 if ( strict )
786 {
787 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
788 }
789 else
790 {
791 int unrecognizedTagCount = 1;
792 while( unrecognizedTagCount != 0 )
793 {
794 xmlStreamReader.next();
795 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
796 {
797 unrecognizedTagCount++;
798 }
799 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
800 {
801 unrecognizedTagCount--;
802 }
803 }
804 }
805 }
806 }
807 buildDefinitionInstances.put( String.valueOf( buildDefinition.getId() ), buildDefinition );
808 return buildDefinition;
809 }
810
811
812
813
814
815
816
817
818
819
820
821
822 private BuildDefinitionTemplate parseBuildDefinitionTemplate( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
823 throws IOException, XMLStreamException
824 {
825 BuildDefinitionTemplate buildDefinitionTemplate = new BuildDefinitionTemplate();
826 java.util.Set parsed = new java.util.HashSet();
827 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
828 {
829 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
830 {
831 buildDefinitionTemplate.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
832 }
833 else if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
834 {
835 buildDefinitionTemplate.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
836 }
837 else if ( checkFieldWithDuplicate( xmlStreamReader, "continuumDefault", null, parsed ) )
838 {
839 buildDefinitionTemplate.setContinuumDefault( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "continuumDefault", xmlStreamReader ) );
840 }
841 else if ( checkFieldWithDuplicate( xmlStreamReader, "type", null, parsed ) )
842 {
843 buildDefinitionTemplate.setType( getTrimmedValue( xmlStreamReader.getElementText() ) );
844 }
845 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildDefinitions", null, parsed ) )
846 {
847 java.util.List buildDefinitions = new java.util.ArrayList
848 buildDefinitionTemplate.setBuildDefinitions( buildDefinitions );
849 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
850 {
851 if ( xmlStreamReader.getLocalName().equals( "buildDefinition" ) )
852 {
853 String value = xmlStreamReader.getAttributeValue( null, "id" );
854 if ( value != null )
855 {
856
857 if ( buildDefinitionReferences == null )
858 {
859 buildDefinitionReferences = new java.util.HashMap();
860 }
861 java.util.Map refs = (java.util.Map) buildDefinitionReferences.get( buildDefinitionTemplate );
862 if ( refs == null )
863 {
864 refs = new java.util.HashMap();
865 buildDefinitionReferences.put( buildDefinitionTemplate, refs );
866 }
867 refs.put( "buildDefinitions." + buildDefinitions.size(), value );
868 }
869 buildDefinitionTemplate.addBuildDefinition( parseBuildDefinition( "buildDefinition", xmlStreamReader, strict, encoding ) );
870 }
871 else
872 {
873 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
874 }
875 }
876 }
877 else
878 {
879 if ( strict )
880 {
881 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
882 }
883 else
884 {
885 int unrecognizedTagCount = 1;
886 while( unrecognizedTagCount != 0 )
887 {
888 xmlStreamReader.next();
889 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
890 {
891 unrecognizedTagCount++;
892 }
893 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
894 {
895 unrecognizedTagCount--;
896 }
897 }
898 }
899 }
900 }
901 return buildDefinitionTemplate;
902 }
903
904
905
906
907
908
909
910
911
912
913
914
915 private BuildQueue parseBuildQueue( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
916 throws IOException, XMLStreamException
917 {
918 BuildQueue buildQueue = new BuildQueue();
919 java.util.Set parsed = new java.util.HashSet();
920 if ( buildQueueInstances == null )
921 {
922 buildQueueInstances = new java.util.HashMap();
923 }
924 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
925 if ( v != null )
926 {
927 buildQueueInstances.put( v, buildQueue );
928 }
929 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
930 {
931 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
932 {
933 buildQueue.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
934 }
935 else if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
936 {
937 buildQueue.setName( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "" ) ) );
938 }
939 else
940 {
941 if ( strict )
942 {
943 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
944 }
945 else
946 {
947 int unrecognizedTagCount = 1;
948 while( unrecognizedTagCount != 0 )
949 {
950 xmlStreamReader.next();
951 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
952 {
953 unrecognizedTagCount++;
954 }
955 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
956 {
957 unrecognizedTagCount--;
958 }
959 }
960 }
961 }
962 }
963 buildQueueInstances.put( String.valueOf( buildQueue.getId() ), buildQueue );
964 return buildQueue;
965 }
966
967
968
969
970
971
972
973
974
975
976
977
978 private BuildResult parseBuildResult( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
979 throws IOException, XMLStreamException
980 {
981 BuildResult buildResult = new BuildResult();
982 java.util.Set parsed = new java.util.HashSet();
983 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
984 {
985 if ( checkFieldWithDuplicate( xmlStreamReader, "project", null, parsed ) )
986 {
987 String value = xmlStreamReader.getAttributeValue( null, "id" );
988 if ( value != null )
989 {
990
991 if ( projectReferences == null )
992 {
993 projectReferences = new java.util.HashMap();
994 }
995 java.util.Map refs = (java.util.Map) projectReferences.get( buildResult );
996 if ( refs == null )
997 {
998 refs = new java.util.HashMap();
999 projectReferences.put( buildResult, refs );
1000 }
1001 refs.put( "project", value );
1002 }
1003 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
1004 {
1005 xmlStreamReader.next();
1006 }
1007 }
1008 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildDefinition", null, parsed ) )
1009 {
1010 String value = xmlStreamReader.getAttributeValue( null, "id" );
1011 if ( value != null )
1012 {
1013
1014 if ( buildDefinitionReferences == null )
1015 {
1016 buildDefinitionReferences = new java.util.HashMap();
1017 }
1018 java.util.Map refs = (java.util.Map) buildDefinitionReferences.get( buildResult );
1019 if ( refs == null )
1020 {
1021 refs = new java.util.HashMap();
1022 buildDefinitionReferences.put( buildResult, refs );
1023 }
1024 refs.put( "buildDefinition", value );
1025 }
1026 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
1027 {
1028 xmlStreamReader.next();
1029 }
1030 }
1031 else if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
1032 {
1033 buildResult.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
1034 }
1035 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildNumber", null, parsed ) )
1036 {
1037 buildResult.setBuildNumber( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "buildNumber", xmlStreamReader, strict ) );
1038 }
1039 else if ( checkFieldWithDuplicate( xmlStreamReader, "state", null, parsed ) )
1040 {
1041 buildResult.setState( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "state", xmlStreamReader, strict ) );
1042 }
1043 else if ( checkFieldWithDuplicate( xmlStreamReader, "trigger", null, parsed ) )
1044 {
1045 buildResult.setTrigger( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "trigger", xmlStreamReader, strict ) );
1046 }
1047 else if ( checkFieldWithDuplicate( xmlStreamReader, "startTime", null, parsed ) )
1048 {
1049 buildResult.setStartTime( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "startTime", xmlStreamReader, strict ) );
1050 }
1051 else if ( checkFieldWithDuplicate( xmlStreamReader, "endTime", null, parsed ) )
1052 {
1053 buildResult.setEndTime( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "endTime", xmlStreamReader, strict ) );
1054 }
1055 else if ( checkFieldWithDuplicate( xmlStreamReader, "error", null, parsed ) )
1056 {
1057 buildResult.setError( getTrimmedValue( xmlStreamReader.getElementText() ) );
1058 }
1059 else if ( checkFieldWithDuplicate( xmlStreamReader, "success", null, parsed ) )
1060 {
1061 buildResult.setSuccess( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "success", xmlStreamReader ) );
1062 }
1063 else if ( checkFieldWithDuplicate( xmlStreamReader, "exitCode", null, parsed ) )
1064 {
1065 buildResult.setExitCode( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "exitCode", xmlStreamReader, strict ) );
1066 }
1067 else if ( checkFieldWithDuplicate( xmlStreamReader, "scmResult", null, parsed ) )
1068 {
1069 buildResult.setScmResult( parseScmResult( "scmResult", xmlStreamReader, strict, encoding ) );
1070 }
1071 else if ( checkFieldWithDuplicate( xmlStreamReader, "modifiedDependencies", null, parsed ) )
1072 {
1073 java.util.List modifiedDependencies = new java.util.ArrayList
1074 buildResult.setModifiedDependencies( modifiedDependencies );
1075 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1076 {
1077 if ( xmlStreamReader.getLocalName().equals( "modifiedDependency" ) )
1078 {
1079 buildResult.addModifiedDependency( parseProjectDependency( "modifiedDependency", xmlStreamReader, strict, encoding ) );
1080 }
1081 else
1082 {
1083 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1084 }
1085 }
1086 }
1087 else if ( checkFieldWithDuplicate( xmlStreamReader, "lastChangedDate", null, parsed ) )
1088 {
1089 buildResult.setLastChangedDate( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "lastChangedDate", xmlStreamReader, strict ) );
1090 }
1091 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildUrl", null, parsed ) )
1092 {
1093 buildResult.setBuildUrl( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "" ) ) );
1094 }
1095 else
1096 {
1097 if ( strict )
1098 {
1099 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1100 }
1101 else
1102 {
1103 int unrecognizedTagCount = 1;
1104 while( unrecognizedTagCount != 0 )
1105 {
1106 xmlStreamReader.next();
1107 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
1108 {
1109 unrecognizedTagCount++;
1110 }
1111 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
1112 {
1113 unrecognizedTagCount--;
1114 }
1115 }
1116 }
1117 }
1118 }
1119 return buildResult;
1120 }
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133 private ChangeFile parseChangeFile( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1134 throws IOException, XMLStreamException
1135 {
1136 ChangeFile changeFile = new ChangeFile();
1137 java.util.Set parsed = new java.util.HashSet();
1138 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1139 {
1140 if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
1141 {
1142 changeFile.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
1143 }
1144 else if ( checkFieldWithDuplicate( xmlStreamReader, "revision", null, parsed ) )
1145 {
1146 changeFile.setRevision( getTrimmedValue( xmlStreamReader.getElementText() ) );
1147 }
1148 else if ( checkFieldWithDuplicate( xmlStreamReader, "status", null, parsed ) )
1149 {
1150 changeFile.setStatus( getTrimmedValue( xmlStreamReader.getElementText() ) );
1151 }
1152 else
1153 {
1154 if ( strict )
1155 {
1156 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1157 }
1158 else
1159 {
1160 int unrecognizedTagCount = 1;
1161 while( unrecognizedTagCount != 0 )
1162 {
1163 xmlStreamReader.next();
1164 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
1165 {
1166 unrecognizedTagCount++;
1167 }
1168 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
1169 {
1170 unrecognizedTagCount--;
1171 }
1172 }
1173 }
1174 }
1175 }
1176 return changeFile;
1177 }
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190 private ChangeSet parseChangeSet( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1191 throws IOException, XMLStreamException
1192 {
1193 ChangeSet changeSet = new ChangeSet();
1194 java.util.Set parsed = new java.util.HashSet();
1195 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1196 {
1197 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
1198 {
1199 changeSet.setId( getTrimmedValue( xmlStreamReader.getElementText() ) );
1200 }
1201 else if ( checkFieldWithDuplicate( xmlStreamReader, "author", null, parsed ) )
1202 {
1203 changeSet.setAuthor( getTrimmedValue( xmlStreamReader.getElementText() ) );
1204 }
1205 else if ( checkFieldWithDuplicate( xmlStreamReader, "comment", null, parsed ) )
1206 {
1207 changeSet.setComment( getTrimmedValue( xmlStreamReader.getElementText() ) );
1208 }
1209 else if ( checkFieldWithDuplicate( xmlStreamReader, "date", null, parsed ) )
1210 {
1211 changeSet.setDate( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "date", xmlStreamReader, strict ) );
1212 }
1213 else if ( checkFieldWithDuplicate( xmlStreamReader, "files", null, parsed ) )
1214 {
1215 java.util.List files = new java.util.ArrayList
1216 changeSet.setFiles( files );
1217 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1218 {
1219 if ( xmlStreamReader.getLocalName().equals( "file" ) )
1220 {
1221 changeSet.addFile( parseChangeFile( "file", xmlStreamReader, strict, encoding ) );
1222 }
1223 else
1224 {
1225 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1226 }
1227 }
1228 }
1229 else
1230 {
1231 if ( strict )
1232 {
1233 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1234 }
1235 else
1236 {
1237 int unrecognizedTagCount = 1;
1238 while( unrecognizedTagCount != 0 )
1239 {
1240 xmlStreamReader.next();
1241 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
1242 {
1243 unrecognizedTagCount++;
1244 }
1245 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
1246 {
1247 unrecognizedTagCount--;
1248 }
1249 }
1250 }
1251 }
1252 }
1253 return changeSet;
1254 }
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267 private ContinuumDatabase parseContinuumDatabase( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1268 throws IOException, XMLStreamException
1269 {
1270 ContinuumDatabase continuumDatabase = new ContinuumDatabase();
1271 java.util.Set parsed = new java.util.HashSet();
1272 continuumDatabase.setModelEncoding( encoding );
1273 boolean foundRoot = false;
1274 while ( xmlStreamReader.hasNext() )
1275 {
1276 int eventType = xmlStreamReader.next();
1277 if ( eventType == XMLStreamConstants.START_ELEMENT )
1278 {
1279 if ( xmlStreamReader.getLocalName().equals( tagName ) )
1280 {
1281 foundRoot = true;
1282 }
1283 else if ( checkFieldWithDuplicate( xmlStreamReader, "projectGroups", null, parsed ) )
1284 {
1285 java.util.List projectGroups = new java.util.ArrayList
1286 continuumDatabase.setProjectGroups( projectGroups );
1287 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1288 {
1289 if ( xmlStreamReader.getLocalName().equals( "projectGroup" ) )
1290 {
1291 continuumDatabase.addProjectGroup( parseProjectGroup( "projectGroup", xmlStreamReader, strict, encoding ) );
1292 }
1293 else
1294 {
1295 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1296 }
1297 }
1298 }
1299 else if ( checkFieldWithDuplicate( xmlStreamReader, "systemConfiguration", null, parsed ) )
1300 {
1301 continuumDatabase.setSystemConfiguration( parseSystemConfiguration( "systemConfiguration", xmlStreamReader, strict, encoding ) );
1302 }
1303 else if ( checkFieldWithDuplicate( xmlStreamReader, "installations", null, parsed ) )
1304 {
1305 java.util.List installations = new java.util.ArrayList
1306 continuumDatabase.setInstallations( installations );
1307 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1308 {
1309 if ( xmlStreamReader.getLocalName().equals( "installation" ) )
1310 {
1311 continuumDatabase.addInstallation( parseInstallation( "installation", xmlStreamReader, strict, encoding ) );
1312 }
1313 else
1314 {
1315 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1316 }
1317 }
1318 }
1319 else if ( checkFieldWithDuplicate( xmlStreamReader, "schedules", null, parsed ) )
1320 {
1321 java.util.List schedules = new java.util.ArrayList
1322 continuumDatabase.setSchedules( schedules );
1323 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1324 {
1325 if ( xmlStreamReader.getLocalName().equals( "schedule" ) )
1326 {
1327 continuumDatabase.addSchedule( parseSchedule( "schedule", xmlStreamReader, strict, encoding ) );
1328 }
1329 else
1330 {
1331 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1332 }
1333 }
1334 }
1335 else if ( checkFieldWithDuplicate( xmlStreamReader, "profiles", null, parsed ) )
1336 {
1337 java.util.List profiles = new java.util.ArrayList
1338 continuumDatabase.setProfiles( profiles );
1339 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1340 {
1341 if ( xmlStreamReader.getLocalName().equals( "profile" ) )
1342 {
1343 continuumDatabase.addProfile( parseProfile( "profile", xmlStreamReader, strict, encoding ) );
1344 }
1345 else
1346 {
1347 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1348 }
1349 }
1350 }
1351 else if ( checkFieldWithDuplicate( xmlStreamReader, "localRepositories", null, parsed ) )
1352 {
1353 java.util.List localRepositories = new java.util.ArrayList
1354 continuumDatabase.setLocalRepositories( localRepositories );
1355 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1356 {
1357 if ( xmlStreamReader.getLocalName().equals( "localRepository" ) )
1358 {
1359 continuumDatabase.addLocalRepository( parseLocalRepository( "localRepository", xmlStreamReader, strict, encoding ) );
1360 }
1361 else
1362 {
1363 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1364 }
1365 }
1366 }
1367 else if ( checkFieldWithDuplicate( xmlStreamReader, "repositoryPurgeConfigurations", null, parsed ) )
1368 {
1369 java.util.List repositoryPurgeConfigurations = new java.util.ArrayList
1370 continuumDatabase.setRepositoryPurgeConfigurations( repositoryPurgeConfigurations );
1371 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1372 {
1373 if ( xmlStreamReader.getLocalName().equals( "repositoryPurgeConfiguration" ) )
1374 {
1375 continuumDatabase.addRepositoryPurgeConfiguration( parseRepositoryPurgeConfiguration( "repositoryPurgeConfiguration", xmlStreamReader, strict, encoding ) );
1376 }
1377 else
1378 {
1379 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1380 }
1381 }
1382 }
1383 else if ( checkFieldWithDuplicate( xmlStreamReader, "directoryPurgeConfigurations", null, parsed ) )
1384 {
1385 java.util.List directoryPurgeConfigurations = new java.util.ArrayList
1386 continuumDatabase.setDirectoryPurgeConfigurations( directoryPurgeConfigurations );
1387 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1388 {
1389 if ( xmlStreamReader.getLocalName().equals( "directoryPurgeConfiguration" ) )
1390 {
1391 continuumDatabase.addDirectoryPurgeConfiguration( parseDirectoryPurgeConfiguration( "directoryPurgeConfiguration", xmlStreamReader, strict, encoding ) );
1392 }
1393 else
1394 {
1395 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1396 }
1397 }
1398 }
1399 else if ( checkFieldWithDuplicate( xmlStreamReader, "projectScmRoots", null, parsed ) )
1400 {
1401 java.util.List projectScmRoots = new java.util.ArrayList
1402 continuumDatabase.setProjectScmRoots( projectScmRoots );
1403 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1404 {
1405 if ( xmlStreamReader.getLocalName().equals( "projectScmRoot" ) )
1406 {
1407 continuumDatabase.addProjectScmRoot( parseProjectScmRoot( "projectScmRoot", xmlStreamReader, strict, encoding ) );
1408 }
1409 else
1410 {
1411 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1412 }
1413 }
1414 }
1415 else if ( checkFieldWithDuplicate( xmlStreamReader, "continuumReleaseResults", null, parsed ) )
1416 {
1417 java.util.List continuumReleaseResults = new java.util.ArrayList
1418 continuumDatabase.setContinuumReleaseResults( continuumReleaseResults );
1419 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1420 {
1421 if ( xmlStreamReader.getLocalName().equals( "continuumReleaseResult" ) )
1422 {
1423 continuumDatabase.addContinuumReleaseResult( parseContinuumReleaseResult( "continuumReleaseResult", xmlStreamReader, strict, encoding ) );
1424 }
1425 else
1426 {
1427 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1428 }
1429 }
1430 }
1431 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildDefinitionTemplates", null, parsed ) )
1432 {
1433 java.util.List buildDefinitionTemplates = new java.util.ArrayList
1434 continuumDatabase.setBuildDefinitionTemplates( buildDefinitionTemplates );
1435 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1436 {
1437 if ( xmlStreamReader.getLocalName().equals( "buildDefinitionTemplate" ) )
1438 {
1439 continuumDatabase.addBuildDefinitionTemplate( parseBuildDefinitionTemplate( "buildDefinitionTemplate", xmlStreamReader, strict, encoding ) );
1440 }
1441 else
1442 {
1443 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1444 }
1445 }
1446 }
1447 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildQueues", null, parsed ) )
1448 {
1449 java.util.List buildQueues = new java.util.ArrayList
1450 continuumDatabase.setBuildQueues( buildQueues );
1451 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1452 {
1453 if ( xmlStreamReader.getLocalName().equals( "buildQueue" ) )
1454 {
1455 continuumDatabase.addBuildQueue( parseBuildQueue( "buildQueue", xmlStreamReader, strict, encoding ) );
1456 }
1457 else
1458 {
1459 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1460 }
1461 }
1462 }
1463 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildDefinitions", null, parsed ) )
1464 {
1465 java.util.List buildDefinitions = new java.util.ArrayList
1466 continuumDatabase.setBuildDefinitions( buildDefinitions );
1467 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1468 {
1469 if ( xmlStreamReader.getLocalName().equals( "buildDefinition" ) )
1470 {
1471 continuumDatabase.addBuildDefinition( parseBuildDefinition( "buildDefinition", xmlStreamReader, strict, encoding ) );
1472 }
1473 else
1474 {
1475 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1476 }
1477 }
1478 }
1479 else
1480 {
1481 if ( foundRoot )
1482 {
1483 if ( strict )
1484 {
1485 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1486 }
1487 }
1488 }
1489 }
1490 }
1491 return continuumDatabase;
1492 }
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505 private ContinuumProjectState parseContinuumProjectState( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1506 throws IOException, XMLStreamException
1507 {
1508 ContinuumProjectState continuumProjectState = new ContinuumProjectState();
1509 java.util.Set parsed = new java.util.HashSet();
1510 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1511 {
1512 if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
1513 {
1514 continuumProjectState.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
1515 }
1516 else
1517 {
1518 if ( strict )
1519 {
1520 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1521 }
1522 else
1523 {
1524 int unrecognizedTagCount = 1;
1525 while( unrecognizedTagCount != 0 )
1526 {
1527 xmlStreamReader.next();
1528 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
1529 {
1530 unrecognizedTagCount++;
1531 }
1532 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
1533 {
1534 unrecognizedTagCount--;
1535 }
1536 }
1537 }
1538 }
1539 }
1540 return continuumProjectState;
1541 }
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554 private ContinuumReleaseResult parseContinuumReleaseResult( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1555 throws IOException, XMLStreamException
1556 {
1557 ContinuumReleaseResult continuumReleaseResult = new ContinuumReleaseResult();
1558 java.util.Set parsed = new java.util.HashSet();
1559 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1560 {
1561 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
1562 {
1563 continuumReleaseResult.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
1564 }
1565 else if ( checkFieldWithDuplicate( xmlStreamReader, "startTime", null, parsed ) )
1566 {
1567 continuumReleaseResult.setStartTime( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "startTime", xmlStreamReader, strict ) );
1568 }
1569 else if ( checkFieldWithDuplicate( xmlStreamReader, "endTime", null, parsed ) )
1570 {
1571 continuumReleaseResult.setEndTime( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "endTime", xmlStreamReader, strict ) );
1572 }
1573 else if ( checkFieldWithDuplicate( xmlStreamReader, "resultCode", null, parsed ) )
1574 {
1575 continuumReleaseResult.setResultCode( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "resultCode", xmlStreamReader, strict ) );
1576 }
1577 else if ( checkFieldWithDuplicate( xmlStreamReader, "projectGroup", null, parsed ) )
1578 {
1579 String value = xmlStreamReader.getAttributeValue( null, "id" );
1580 if ( value != null )
1581 {
1582
1583 if ( projectGroupReferences == null )
1584 {
1585 projectGroupReferences = new java.util.HashMap();
1586 }
1587 java.util.Map refs = (java.util.Map) projectGroupReferences.get( continuumReleaseResult );
1588 if ( refs == null )
1589 {
1590 refs = new java.util.HashMap();
1591 projectGroupReferences.put( continuumReleaseResult, refs );
1592 }
1593 refs.put( "projectGroup", value );
1594 }
1595 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
1596 {
1597 xmlStreamReader.next();
1598 }
1599 }
1600 else if ( checkFieldWithDuplicate( xmlStreamReader, "project", null, parsed ) )
1601 {
1602 String value = xmlStreamReader.getAttributeValue( null, "id" );
1603 if ( value != null )
1604 {
1605
1606 if ( projectReferences == null )
1607 {
1608 projectReferences = new java.util.HashMap();
1609 }
1610 java.util.Map refs = (java.util.Map) projectReferences.get( continuumReleaseResult );
1611 if ( refs == null )
1612 {
1613 refs = new java.util.HashMap();
1614 projectReferences.put( continuumReleaseResult, refs );
1615 }
1616 refs.put( "project", value );
1617 }
1618 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
1619 {
1620 xmlStreamReader.next();
1621 }
1622 }
1623 else if ( checkFieldWithDuplicate( xmlStreamReader, "releaseGoal", null, parsed ) )
1624 {
1625 continuumReleaseResult.setReleaseGoal( getTrimmedValue( xmlStreamReader.getElementText() ) );
1626 }
1627 else
1628 {
1629 if ( strict )
1630 {
1631 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1632 }
1633 else
1634 {
1635 int unrecognizedTagCount = 1;
1636 while( unrecognizedTagCount != 0 )
1637 {
1638 xmlStreamReader.next();
1639 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
1640 {
1641 unrecognizedTagCount++;
1642 }
1643 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
1644 {
1645 unrecognizedTagCount--;
1646 }
1647 }
1648 }
1649 }
1650 }
1651 return continuumReleaseResult;
1652 }
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665 private DirectoryPurgeConfiguration parseDirectoryPurgeConfiguration( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1666 throws IOException, XMLStreamException
1667 {
1668 DirectoryPurgeConfiguration directoryPurgeConfiguration = new DirectoryPurgeConfiguration();
1669 java.util.Set parsed = new java.util.HashSet();
1670 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1671 {
1672 if ( checkFieldWithDuplicate( xmlStreamReader, "location", null, parsed ) )
1673 {
1674 directoryPurgeConfiguration.setLocation( getTrimmedValue( xmlStreamReader.getElementText() ) );
1675 }
1676 else if ( checkFieldWithDuplicate( xmlStreamReader, "directoryType", null, parsed ) )
1677 {
1678 directoryPurgeConfiguration.setDirectoryType( getTrimmedValue( xmlStreamReader.getElementText() ) );
1679 }
1680 else if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
1681 {
1682 directoryPurgeConfiguration.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
1683 }
1684 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
1685 {
1686 directoryPurgeConfiguration.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
1687 }
1688 else if ( checkFieldWithDuplicate( xmlStreamReader, "deleteAll", null, parsed ) )
1689 {
1690 directoryPurgeConfiguration.setDeleteAll( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "deleteAll", xmlStreamReader ) );
1691 }
1692 else if ( checkFieldWithDuplicate( xmlStreamReader, "retentionCount", null, parsed ) )
1693 {
1694 directoryPurgeConfiguration.setRetentionCount( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "2" ) ), "retentionCount", xmlStreamReader, strict ) );
1695 }
1696 else if ( checkFieldWithDuplicate( xmlStreamReader, "daysOlder", null, parsed ) )
1697 {
1698 directoryPurgeConfiguration.setDaysOlder( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "100" ) ), "daysOlder", xmlStreamReader, strict ) );
1699 }
1700 else if ( checkFieldWithDuplicate( xmlStreamReader, "enabled", null, parsed ) )
1701 {
1702 directoryPurgeConfiguration.setEnabled( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "enabled", xmlStreamReader ) );
1703 }
1704 else if ( checkFieldWithDuplicate( xmlStreamReader, "schedule", null, parsed ) )
1705 {
1706 String value = xmlStreamReader.getAttributeValue( null, "id" );
1707 if ( value != null )
1708 {
1709
1710 if ( scheduleReferences == null )
1711 {
1712 scheduleReferences = new java.util.HashMap();
1713 }
1714 java.util.Map refs = (java.util.Map) scheduleReferences.get( directoryPurgeConfiguration );
1715 if ( refs == null )
1716 {
1717 refs = new java.util.HashMap();
1718 scheduleReferences.put( directoryPurgeConfiguration, refs );
1719 }
1720 refs.put( "schedule", value );
1721 }
1722 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
1723 {
1724 xmlStreamReader.next();
1725 }
1726 }
1727 else if ( checkFieldWithDuplicate( xmlStreamReader, "defaultPurge", null, parsed ) )
1728 {
1729 directoryPurgeConfiguration.setDefaultPurge( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "defaultPurge", xmlStreamReader ) );
1730 }
1731 else
1732 {
1733 if ( strict )
1734 {
1735 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1736 }
1737 else
1738 {
1739 int unrecognizedTagCount = 1;
1740 while( unrecognizedTagCount != 0 )
1741 {
1742 xmlStreamReader.next();
1743 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
1744 {
1745 unrecognizedTagCount++;
1746 }
1747 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
1748 {
1749 unrecognizedTagCount--;
1750 }
1751 }
1752 }
1753 }
1754 }
1755 return directoryPurgeConfiguration;
1756 }
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769 private Installation parseInstallation( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1770 throws IOException, XMLStreamException
1771 {
1772 Installation installation = new Installation();
1773 java.util.Set parsed = new java.util.HashSet();
1774 if ( installationInstances == null )
1775 {
1776 installationInstances = new java.util.HashMap();
1777 }
1778 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
1779 if ( v != null )
1780 {
1781 installationInstances.put( v, installation );
1782 }
1783 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1784 {
1785 if ( checkFieldWithDuplicate( xmlStreamReader, "type", null, parsed ) )
1786 {
1787 installation.setType( getTrimmedValue( xmlStreamReader.getElementText() ) );
1788 }
1789 else if ( checkFieldWithDuplicate( xmlStreamReader, "varValue", null, parsed ) )
1790 {
1791 installation.setVarValue( getTrimmedValue( xmlStreamReader.getElementText() ) );
1792 }
1793 else if ( checkFieldWithDuplicate( xmlStreamReader, "varName", null, parsed ) )
1794 {
1795 installation.setVarName( getTrimmedValue( xmlStreamReader.getElementText() ) );
1796 }
1797 else if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
1798 {
1799 installation.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
1800 }
1801 else if ( checkFieldWithDuplicate( xmlStreamReader, "installationId", null, parsed ) )
1802 {
1803 installation.setInstallationId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "installationId", xmlStreamReader, strict ) );
1804 }
1805 else
1806 {
1807 if ( strict )
1808 {
1809 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1810 }
1811 else
1812 {
1813 int unrecognizedTagCount = 1;
1814 while( unrecognizedTagCount != 0 )
1815 {
1816 xmlStreamReader.next();
1817 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
1818 {
1819 unrecognizedTagCount++;
1820 }
1821 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
1822 {
1823 unrecognizedTagCount--;
1824 }
1825 }
1826 }
1827 }
1828 }
1829 installationInstances.put( String.valueOf( installation.getInstallationId() ), installation );
1830 return installation;
1831 }
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844 private LocalRepository parseLocalRepository( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1845 throws IOException, XMLStreamException
1846 {
1847 LocalRepository localRepository = new LocalRepository();
1848 java.util.Set parsed = new java.util.HashSet();
1849 if ( localRepositoryInstances == null )
1850 {
1851 localRepositoryInstances = new java.util.HashMap();
1852 }
1853 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
1854 if ( v != null )
1855 {
1856 localRepositoryInstances.put( v, localRepository );
1857 }
1858 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1859 {
1860 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
1861 {
1862 localRepository.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
1863 }
1864 else if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
1865 {
1866 localRepository.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
1867 }
1868 else if ( checkFieldWithDuplicate( xmlStreamReader, "location", null, parsed ) )
1869 {
1870 localRepository.setLocation( getTrimmedValue( xmlStreamReader.getElementText() ) );
1871 }
1872 else if ( checkFieldWithDuplicate( xmlStreamReader, "layout", null, parsed ) )
1873 {
1874 localRepository.setLayout( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "default" ) ) );
1875 }
1876 else
1877 {
1878 if ( strict )
1879 {
1880 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1881 }
1882 else
1883 {
1884 int unrecognizedTagCount = 1;
1885 while( unrecognizedTagCount != 0 )
1886 {
1887 xmlStreamReader.next();
1888 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
1889 {
1890 unrecognizedTagCount++;
1891 }
1892 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
1893 {
1894 unrecognizedTagCount--;
1895 }
1896 }
1897 }
1898 }
1899 }
1900 localRepositoryInstances.put( String.valueOf( localRepository.getId() ), localRepository );
1901 return localRepository;
1902 }
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915 private NotificationAddress parseNotificationAddress( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1916 throws IOException, XMLStreamException
1917 {
1918 NotificationAddress notificationAddress = new NotificationAddress();
1919 java.util.Set parsed = new java.util.HashSet();
1920 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1921 {
1922 if ( checkFieldWithDuplicate( xmlStreamReader, "type", null, parsed ) )
1923 {
1924 notificationAddress.setType( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "mail" ) ) );
1925 }
1926 else if ( checkFieldWithDuplicate( xmlStreamReader, "address", null, parsed ) )
1927 {
1928 notificationAddress.setAddress( getTrimmedValue( xmlStreamReader.getElementText() ) );
1929 }
1930 else if ( checkFieldWithDuplicate( xmlStreamReader, "configuration", null, parsed ) )
1931 {
1932 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1933 {
1934 String key = xmlStreamReader.getLocalName();
1935 String value = xmlStreamReader.getElementText().trim();
1936 notificationAddress.addConfiguration( key, value );
1937 }
1938 }
1939 else
1940 {
1941 if ( strict )
1942 {
1943 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
1944 }
1945 else
1946 {
1947 int unrecognizedTagCount = 1;
1948 while( unrecognizedTagCount != 0 )
1949 {
1950 xmlStreamReader.next();
1951 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
1952 {
1953 unrecognizedTagCount++;
1954 }
1955 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
1956 {
1957 unrecognizedTagCount--;
1958 }
1959 }
1960 }
1961 }
1962 }
1963 return notificationAddress;
1964 }
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977 private Profile parseProfile( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
1978 throws IOException, XMLStreamException
1979 {
1980 Profile profile = new Profile();
1981 java.util.Set parsed = new java.util.HashSet();
1982 if ( profileInstances == null )
1983 {
1984 profileInstances = new java.util.HashMap();
1985 }
1986 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
1987 if ( v != null )
1988 {
1989 profileInstances.put( v, profile );
1990 }
1991 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
1992 {
1993 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
1994 {
1995 profile.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
1996 }
1997 else if ( checkFieldWithDuplicate( xmlStreamReader, "active", null, parsed ) )
1998 {
1999 profile.setActive( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "active", xmlStreamReader ) );
2000 }
2001 else if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
2002 {
2003 profile.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
2004 }
2005 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
2006 {
2007 profile.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
2008 }
2009 else if ( checkFieldWithDuplicate( xmlStreamReader, "scmMode", null, parsed ) )
2010 {
2011 profile.setScmMode( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "scmMode", xmlStreamReader, strict ) );
2012 }
2013 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildWithoutChanges", null, parsed ) )
2014 {
2015 profile.setBuildWithoutChanges( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "buildWithoutChanges", xmlStreamReader ) );
2016 }
2017 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildAgentGroup", null, parsed ) )
2018 {
2019 profile.setBuildAgentGroup( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "" ) ) );
2020 }
2021 else if ( checkFieldWithDuplicate( xmlStreamReader, "jdk", null, parsed ) )
2022 {
2023 String value = xmlStreamReader.getAttributeValue( null, "installationId" );
2024 if ( value != null )
2025 {
2026
2027 if ( installationReferences == null )
2028 {
2029 installationReferences = new java.util.HashMap();
2030 }
2031 java.util.Map refs = (java.util.Map) installationReferences.get( profile );
2032 if ( refs == null )
2033 {
2034 refs = new java.util.HashMap();
2035 installationReferences.put( profile, refs );
2036 }
2037 refs.put( "jdk", value );
2038 }
2039 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
2040 {
2041 xmlStreamReader.next();
2042 }
2043 }
2044 else if ( checkFieldWithDuplicate( xmlStreamReader, "builder", null, parsed ) )
2045 {
2046 String value = xmlStreamReader.getAttributeValue( null, "installationId" );
2047 if ( value != null )
2048 {
2049
2050 if ( installationReferences == null )
2051 {
2052 installationReferences = new java.util.HashMap();
2053 }
2054 java.util.Map refs = (java.util.Map) installationReferences.get( profile );
2055 if ( refs == null )
2056 {
2057 refs = new java.util.HashMap();
2058 installationReferences.put( profile, refs );
2059 }
2060 refs.put( "builder", value );
2061 }
2062 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
2063 {
2064 xmlStreamReader.next();
2065 }
2066 }
2067 else if ( checkFieldWithDuplicate( xmlStreamReader, "environmentVariables", null, parsed ) )
2068 {
2069 java.util.List environmentVariables = new java.util.ArrayList
2070 profile.setEnvironmentVariables( environmentVariables );
2071 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2072 {
2073 if ( xmlStreamReader.getLocalName().equals( "environmentVariable" ) )
2074 {
2075 String value = xmlStreamReader.getAttributeValue( null, "installationId" );
2076 if ( value != null )
2077 {
2078
2079 if ( installationReferences == null )
2080 {
2081 installationReferences = new java.util.HashMap();
2082 }
2083 java.util.Map refs = (java.util.Map) installationReferences.get( profile );
2084 if ( refs == null )
2085 {
2086 refs = new java.util.HashMap();
2087 installationReferences.put( profile, refs );
2088 }
2089 refs.put( "environmentVariables." + environmentVariables.size(), value );
2090 }
2091 profile.addEnvironmentVariable( parseInstallation( "environmentVariable", xmlStreamReader, strict, encoding ) );
2092 }
2093 else
2094 {
2095 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2096 }
2097 }
2098 }
2099 else
2100 {
2101 if ( strict )
2102 {
2103 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2104 }
2105 else
2106 {
2107 int unrecognizedTagCount = 1;
2108 while( unrecognizedTagCount != 0 )
2109 {
2110 xmlStreamReader.next();
2111 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
2112 {
2113 unrecognizedTagCount++;
2114 }
2115 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
2116 {
2117 unrecognizedTagCount--;
2118 }
2119 }
2120 }
2121 }
2122 }
2123 profileInstances.put( String.valueOf( profile.getId() ), profile );
2124 return profile;
2125 }
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138 private Project parseProject( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
2139 throws IOException, XMLStreamException
2140 {
2141 Project project = new Project();
2142 java.util.Set parsed = new java.util.HashSet();
2143 if ( projectInstances == null )
2144 {
2145 projectInstances = new java.util.HashMap();
2146 }
2147 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
2148 if ( v != null )
2149 {
2150 projectInstances.put( v, project );
2151 }
2152 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2153 {
2154 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
2155 {
2156 project.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
2157 }
2158 else if ( checkFieldWithDuplicate( xmlStreamReader, "groupId", null, parsed ) )
2159 {
2160 project.setGroupId( getTrimmedValue( xmlStreamReader.getElementText() ) );
2161 }
2162 else if ( checkFieldWithDuplicate( xmlStreamReader, "artifactId", null, parsed ) )
2163 {
2164 project.setArtifactId( getTrimmedValue( xmlStreamReader.getElementText() ) );
2165 }
2166 else if ( checkFieldWithDuplicate( xmlStreamReader, "executorId", null, parsed ) )
2167 {
2168 project.setExecutorId( getTrimmedValue( xmlStreamReader.getElementText() ) );
2169 }
2170 else if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
2171 {
2172 project.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
2173 }
2174 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
2175 {
2176 project.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
2177 }
2178 else if ( checkFieldWithDuplicate( xmlStreamReader, "url", null, parsed ) )
2179 {
2180 project.setUrl( getTrimmedValue( xmlStreamReader.getElementText() ) );
2181 }
2182 else if ( checkFieldWithDuplicate( xmlStreamReader, "scmUrl", null, parsed ) )
2183 {
2184 project.setScmUrl( getTrimmedValue( xmlStreamReader.getElementText() ) );
2185 }
2186 else if ( checkFieldWithDuplicate( xmlStreamReader, "scmTag", null, parsed ) )
2187 {
2188 project.setScmTag( getTrimmedValue( xmlStreamReader.getElementText() ) );
2189 }
2190 else if ( checkFieldWithDuplicate( xmlStreamReader, "scmUsername", null, parsed ) )
2191 {
2192 project.setScmUsername( getTrimmedValue( xmlStreamReader.getElementText() ) );
2193 }
2194 else if ( checkFieldWithDuplicate( xmlStreamReader, "scmPassword", null, parsed ) )
2195 {
2196 project.setScmPassword( getTrimmedValue( xmlStreamReader.getElementText() ) );
2197 }
2198 else if ( checkFieldWithDuplicate( xmlStreamReader, "scmUseCache", null, parsed ) )
2199 {
2200 project.setScmUseCache( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "scmUseCache", xmlStreamReader ) );
2201 }
2202 else if ( checkFieldWithDuplicate( xmlStreamReader, "version", null, parsed ) )
2203 {
2204 project.setVersion( getTrimmedValue( xmlStreamReader.getElementText() ) );
2205 }
2206 else if ( checkFieldWithDuplicate( xmlStreamReader, "state", null, parsed ) )
2207 {
2208 project.setState( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "1" ) ), "state", xmlStreamReader, strict ) );
2209 }
2210 else if ( checkFieldWithDuplicate( xmlStreamReader, "oldState", null, parsed ) )
2211 {
2212 project.setOldState( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "oldState", xmlStreamReader, strict ) );
2213 }
2214 else if ( checkFieldWithDuplicate( xmlStreamReader, "latestBuildId", null, parsed ) )
2215 {
2216 project.setLatestBuildId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "latestBuildId", xmlStreamReader, strict ) );
2217 }
2218 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildNumber", null, parsed ) )
2219 {
2220 project.setBuildNumber( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "buildNumber", xmlStreamReader, strict ) );
2221 }
2222 else if ( checkFieldWithDuplicate( xmlStreamReader, "workingDirectory", null, parsed ) )
2223 {
2224 project.setWorkingDirectory( getTrimmedValue( xmlStreamReader.getElementText() ) );
2225 }
2226 else if ( checkFieldWithDuplicate( xmlStreamReader, "relativePath", null, parsed ) )
2227 {
2228 project.setRelativePath( getTrimmedValue( xmlStreamReader.getElementText() ) );
2229 }
2230 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildResults", null, parsed ) )
2231 {
2232 java.util.List buildResults = new java.util.ArrayList
2233 project.setBuildResults( buildResults );
2234 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2235 {
2236 if ( xmlStreamReader.getLocalName().equals( "buildResult" ) )
2237 {
2238 project.addBuildResult( parseBuildResult( "buildResult", xmlStreamReader, strict, encoding ) );
2239 }
2240 else
2241 {
2242 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2243 }
2244 }
2245 }
2246 else if ( checkFieldWithDuplicate( xmlStreamReader, "checkoutResult", null, parsed ) )
2247 {
2248 project.setCheckoutResult( parseScmResult( "checkoutResult", xmlStreamReader, strict, encoding ) );
2249 }
2250 else if ( checkFieldWithDuplicate( xmlStreamReader, "developers", null, parsed ) )
2251 {
2252 java.util.List developers = new java.util.ArrayList
2253 project.setDevelopers( developers );
2254 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2255 {
2256 if ( xmlStreamReader.getLocalName().equals( "developer" ) )
2257 {
2258 project.addDeveloper( parseProjectDeveloper( "developer", xmlStreamReader, strict, encoding ) );
2259 }
2260 else
2261 {
2262 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2263 }
2264 }
2265 }
2266 else if ( checkFieldWithDuplicate( xmlStreamReader, "parent", null, parsed ) )
2267 {
2268 project.setParent( parseProjectDependency( "parent", xmlStreamReader, strict, encoding ) );
2269 }
2270 else if ( checkFieldWithDuplicate( xmlStreamReader, "dependencies", null, parsed ) )
2271 {
2272 java.util.List dependencies = new java.util.ArrayList
2273 project.setDependencies( dependencies );
2274 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2275 {
2276 if ( xmlStreamReader.getLocalName().equals( "dependency" ) )
2277 {
2278 project.addDependency( parseProjectDependency( "dependency", xmlStreamReader, strict, encoding ) );
2279 }
2280 else
2281 {
2282 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2283 }
2284 }
2285 }
2286 else if ( checkFieldWithDuplicate( xmlStreamReader, "projectGroup", null, parsed ) )
2287 {
2288 String value = xmlStreamReader.getAttributeValue( null, "id" );
2289 if ( value != null )
2290 {
2291
2292 if ( projectGroupReferences == null )
2293 {
2294 projectGroupReferences = new java.util.HashMap();
2295 }
2296 java.util.Map refs = (java.util.Map) projectGroupReferences.get( project );
2297 if ( refs == null )
2298 {
2299 refs = new java.util.HashMap();
2300 projectGroupReferences.put( project, refs );
2301 }
2302 refs.put( "projectGroup", value );
2303 }
2304 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
2305 {
2306 xmlStreamReader.next();
2307 }
2308 }
2309 else if ( checkFieldWithDuplicate( xmlStreamReader, "notifiers", null, parsed ) )
2310 {
2311 java.util.List notifiers = new java.util.ArrayList
2312 project.setNotifiers( notifiers );
2313 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2314 {
2315 if ( xmlStreamReader.getLocalName().equals( "notifier" ) )
2316 {
2317 project.addNotifier( parseProjectNotifier( "notifier", xmlStreamReader, strict, encoding ) );
2318 }
2319 else
2320 {
2321 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2322 }
2323 }
2324 }
2325 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildDefinitions", null, parsed ) )
2326 {
2327 java.util.List buildDefinitions = new java.util.ArrayList
2328 project.setBuildDefinitions( buildDefinitions );
2329 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2330 {
2331 if ( xmlStreamReader.getLocalName().equals( "buildDefinition" ) )
2332 {
2333 project.addBuildDefinition( parseBuildDefinition( "buildDefinition", xmlStreamReader, strict, encoding ) );
2334 }
2335 else
2336 {
2337 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2338 }
2339 }
2340 }
2341 else
2342 {
2343 if ( strict )
2344 {
2345 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2346 }
2347 else
2348 {
2349 int unrecognizedTagCount = 1;
2350 while( unrecognizedTagCount != 0 )
2351 {
2352 xmlStreamReader.next();
2353 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
2354 {
2355 unrecognizedTagCount++;
2356 }
2357 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
2358 {
2359 unrecognizedTagCount--;
2360 }
2361 }
2362 }
2363 }
2364 }
2365 projectInstances.put( String.valueOf( project.getId() ), project );
2366 return project;
2367 }
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380 private ProjectDependency parseProjectDependency( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
2381 throws IOException, XMLStreamException
2382 {
2383 ProjectDependency projectDependency = new ProjectDependency();
2384 java.util.Set parsed = new java.util.HashSet();
2385 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2386 {
2387 if ( checkFieldWithDuplicate( xmlStreamReader, "groupId", null, parsed ) )
2388 {
2389 projectDependency.setGroupId( getTrimmedValue( xmlStreamReader.getElementText() ) );
2390 }
2391 else if ( checkFieldWithDuplicate( xmlStreamReader, "artifactId", null, parsed ) )
2392 {
2393 projectDependency.setArtifactId( getTrimmedValue( xmlStreamReader.getElementText() ) );
2394 }
2395 else if ( checkFieldWithDuplicate( xmlStreamReader, "version", null, parsed ) )
2396 {
2397 projectDependency.setVersion( getTrimmedValue( xmlStreamReader.getElementText() ) );
2398 }
2399 else
2400 {
2401 if ( strict )
2402 {
2403 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2404 }
2405 else
2406 {
2407 int unrecognizedTagCount = 1;
2408 while( unrecognizedTagCount != 0 )
2409 {
2410 xmlStreamReader.next();
2411 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
2412 {
2413 unrecognizedTagCount++;
2414 }
2415 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
2416 {
2417 unrecognizedTagCount--;
2418 }
2419 }
2420 }
2421 }
2422 }
2423 return projectDependency;
2424 }
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437 private ProjectDeveloper parseProjectDeveloper( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
2438 throws IOException, XMLStreamException
2439 {
2440 ProjectDeveloper projectDeveloper = new ProjectDeveloper();
2441 java.util.Set parsed = new java.util.HashSet();
2442 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2443 {
2444 if ( checkFieldWithDuplicate( xmlStreamReader, "scmId", null, parsed ) )
2445 {
2446 projectDeveloper.setScmId( getTrimmedValue( xmlStreamReader.getElementText() ) );
2447 }
2448 else if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
2449 {
2450 projectDeveloper.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
2451 }
2452 else if ( checkFieldWithDuplicate( xmlStreamReader, "email", null, parsed ) )
2453 {
2454 projectDeveloper.setEmail( getTrimmedValue( xmlStreamReader.getElementText() ) );
2455 }
2456 else if ( checkFieldWithDuplicate( xmlStreamReader, "continuumId", null, parsed ) )
2457 {
2458 projectDeveloper.setContinuumId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "continuumId", xmlStreamReader, strict ) );
2459 }
2460 else
2461 {
2462 if ( strict )
2463 {
2464 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2465 }
2466 else
2467 {
2468 int unrecognizedTagCount = 1;
2469 while( unrecognizedTagCount != 0 )
2470 {
2471 xmlStreamReader.next();
2472 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
2473 {
2474 unrecognizedTagCount++;
2475 }
2476 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
2477 {
2478 unrecognizedTagCount--;
2479 }
2480 }
2481 }
2482 }
2483 }
2484 return projectDeveloper;
2485 }
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498 private ProjectGroup parseProjectGroup( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
2499 throws IOException, XMLStreamException
2500 {
2501 ProjectGroup projectGroup = new ProjectGroup();
2502 java.util.Set parsed = new java.util.HashSet();
2503 if ( projectGroupInstances == null )
2504 {
2505 projectGroupInstances = new java.util.HashMap();
2506 }
2507 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
2508 if ( v != null )
2509 {
2510 projectGroupInstances.put( v, projectGroup );
2511 }
2512 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2513 {
2514 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
2515 {
2516 projectGroup.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
2517 }
2518 else if ( checkFieldWithDuplicate( xmlStreamReader, "groupId", null, parsed ) )
2519 {
2520 projectGroup.setGroupId( getTrimmedValue( xmlStreamReader.getElementText() ) );
2521 }
2522 else if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
2523 {
2524 projectGroup.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
2525 }
2526 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
2527 {
2528 projectGroup.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
2529 }
2530 else if ( checkFieldWithDuplicate( xmlStreamReader, "projects", null, parsed ) )
2531 {
2532 java.util.List projects = new java.util.ArrayList
2533 projectGroup.setProjects( projects );
2534 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2535 {
2536 if ( xmlStreamReader.getLocalName().equals( "project" ) )
2537 {
2538 projectGroup.addProject( parseProject( "project", xmlStreamReader, strict, encoding ) );
2539 }
2540 else
2541 {
2542 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2543 }
2544 }
2545 }
2546 else if ( checkFieldWithDuplicate( xmlStreamReader, "notifiers", null, parsed ) )
2547 {
2548 java.util.List notifiers = new java.util.ArrayList
2549 projectGroup.setNotifiers( notifiers );
2550 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2551 {
2552 if ( xmlStreamReader.getLocalName().equals( "notifier" ) )
2553 {
2554 projectGroup.addNotifier( parseProjectNotifier( "notifier", xmlStreamReader, strict, encoding ) );
2555 }
2556 else
2557 {
2558 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2559 }
2560 }
2561 }
2562 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildDefinitions", null, parsed ) )
2563 {
2564 java.util.List buildDefinitions = new java.util.ArrayList
2565 projectGroup.setBuildDefinitions( buildDefinitions );
2566 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2567 {
2568 if ( xmlStreamReader.getLocalName().equals( "buildDefinition" ) )
2569 {
2570 projectGroup.addBuildDefinition( parseBuildDefinition( "buildDefinition", xmlStreamReader, strict, encoding ) );
2571 }
2572 else
2573 {
2574 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2575 }
2576 }
2577 }
2578 else if ( checkFieldWithDuplicate( xmlStreamReader, "localRepository", null, parsed ) )
2579 {
2580 String value = xmlStreamReader.getAttributeValue( null, "id" );
2581 if ( value != null )
2582 {
2583
2584 if ( localRepositoryReferences == null )
2585 {
2586 localRepositoryReferences = new java.util.HashMap();
2587 }
2588 java.util.Map refs = (java.util.Map) localRepositoryReferences.get( projectGroup );
2589 if ( refs == null )
2590 {
2591 refs = new java.util.HashMap();
2592 localRepositoryReferences.put( projectGroup, refs );
2593 }
2594 refs.put( "localRepository", value );
2595 }
2596 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
2597 {
2598 xmlStreamReader.next();
2599 }
2600 }
2601 else
2602 {
2603 if ( strict )
2604 {
2605 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2606 }
2607 else
2608 {
2609 int unrecognizedTagCount = 1;
2610 while( unrecognizedTagCount != 0 )
2611 {
2612 xmlStreamReader.next();
2613 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
2614 {
2615 unrecognizedTagCount++;
2616 }
2617 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
2618 {
2619 unrecognizedTagCount--;
2620 }
2621 }
2622 }
2623 }
2624 }
2625 projectGroupInstances.put( String.valueOf( projectGroup.getId() ), projectGroup );
2626 return projectGroup;
2627 }
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640 private ProjectNotifier parseProjectNotifier( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
2641 throws IOException, XMLStreamException
2642 {
2643 ProjectNotifier projectNotifier = new ProjectNotifier();
2644 java.util.Set parsed = new java.util.HashSet();
2645 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2646 {
2647 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
2648 {
2649 projectNotifier.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
2650 }
2651 else if ( checkFieldWithDuplicate( xmlStreamReader, "type", null, parsed ) )
2652 {
2653 projectNotifier.setType( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "mail" ) ) );
2654 }
2655 else if ( checkFieldWithDuplicate( xmlStreamReader, "from", null, parsed ) )
2656 {
2657 projectNotifier.setFrom( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "from", xmlStreamReader, strict ) );
2658 }
2659 else if ( checkFieldWithDuplicate( xmlStreamReader, "enabled", null, parsed ) )
2660 {
2661 projectNotifier.setEnabled( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "enabled", xmlStreamReader ) );
2662 }
2663 else if ( checkFieldWithDuplicate( xmlStreamReader, "recipientType", null, parsed ) )
2664 {
2665 projectNotifier.setRecipientType( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "recipientType", xmlStreamReader, strict ) );
2666 }
2667 else if ( checkFieldWithDuplicate( xmlStreamReader, "sendOnSuccess", null, parsed ) )
2668 {
2669 projectNotifier.setSendOnSuccess( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "sendOnSuccess", xmlStreamReader ) );
2670 }
2671 else if ( checkFieldWithDuplicate( xmlStreamReader, "sendOnFailure", null, parsed ) )
2672 {
2673 projectNotifier.setSendOnFailure( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "sendOnFailure", xmlStreamReader ) );
2674 }
2675 else if ( checkFieldWithDuplicate( xmlStreamReader, "sendOnError", null, parsed ) )
2676 {
2677 projectNotifier.setSendOnError( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "sendOnError", xmlStreamReader ) );
2678 }
2679 else if ( checkFieldWithDuplicate( xmlStreamReader, "sendOnWarning", null, parsed ) )
2680 {
2681 projectNotifier.setSendOnWarning( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "sendOnWarning", xmlStreamReader ) );
2682 }
2683 else if ( checkFieldWithDuplicate( xmlStreamReader, "configuration", null, parsed ) )
2684 {
2685 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2686 {
2687 String key = xmlStreamReader.getLocalName();
2688 String value = xmlStreamReader.getElementText().trim();
2689 projectNotifier.addConfiguration( key, value );
2690 }
2691 }
2692 else if ( checkFieldWithDuplicate( xmlStreamReader, "sendOnScmFailure", null, parsed ) )
2693 {
2694 projectNotifier.setSendOnScmFailure( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "sendOnScmFailure", xmlStreamReader ) );
2695 }
2696 else
2697 {
2698 if ( strict )
2699 {
2700 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2701 }
2702 else
2703 {
2704 int unrecognizedTagCount = 1;
2705 while( unrecognizedTagCount != 0 )
2706 {
2707 xmlStreamReader.next();
2708 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
2709 {
2710 unrecognizedTagCount++;
2711 }
2712 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
2713 {
2714 unrecognizedTagCount--;
2715 }
2716 }
2717 }
2718 }
2719 }
2720 return projectNotifier;
2721 }
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734 private ProjectScmRoot parseProjectScmRoot( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
2735 throws IOException, XMLStreamException
2736 {
2737 ProjectScmRoot projectScmRoot = new ProjectScmRoot();
2738 java.util.Set parsed = new java.util.HashSet();
2739 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2740 {
2741 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
2742 {
2743 projectScmRoot.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
2744 }
2745 else if ( checkFieldWithDuplicate( xmlStreamReader, "scmRootAddress", null, parsed ) )
2746 {
2747 projectScmRoot.setScmRootAddress( getTrimmedValue( xmlStreamReader.getElementText() ) );
2748 }
2749 else if ( checkFieldWithDuplicate( xmlStreamReader, "oldState", null, parsed ) )
2750 {
2751 projectScmRoot.setOldState( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "oldState", xmlStreamReader, strict ) );
2752 }
2753 else if ( checkFieldWithDuplicate( xmlStreamReader, "state", null, parsed ) )
2754 {
2755 projectScmRoot.setState( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "state", xmlStreamReader, strict ) );
2756 }
2757 else if ( checkFieldWithDuplicate( xmlStreamReader, "error", null, parsed ) )
2758 {
2759 projectScmRoot.setError( getTrimmedValue( xmlStreamReader.getElementText() ) );
2760 }
2761 else if ( checkFieldWithDuplicate( xmlStreamReader, "projectGroup", null, parsed ) )
2762 {
2763 String value = xmlStreamReader.getAttributeValue( null, "id" );
2764 if ( value != null )
2765 {
2766
2767 if ( projectGroupReferences == null )
2768 {
2769 projectGroupReferences = new java.util.HashMap();
2770 }
2771 java.util.Map refs = (java.util.Map) projectGroupReferences.get( projectScmRoot );
2772 if ( refs == null )
2773 {
2774 refs = new java.util.HashMap();
2775 projectGroupReferences.put( projectScmRoot, refs );
2776 }
2777 refs.put( "projectGroup", value );
2778 }
2779 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
2780 {
2781 xmlStreamReader.next();
2782 }
2783 }
2784 else
2785 {
2786 if ( strict )
2787 {
2788 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2789 }
2790 else
2791 {
2792 int unrecognizedTagCount = 1;
2793 while( unrecognizedTagCount != 0 )
2794 {
2795 xmlStreamReader.next();
2796 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
2797 {
2798 unrecognizedTagCount++;
2799 }
2800 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
2801 {
2802 unrecognizedTagCount--;
2803 }
2804 }
2805 }
2806 }
2807 }
2808 return projectScmRoot;
2809 }
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822 private RepositoryPurgeConfiguration parseRepositoryPurgeConfiguration( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
2823 throws IOException, XMLStreamException
2824 {
2825 RepositoryPurgeConfiguration repositoryPurgeConfiguration = new RepositoryPurgeConfiguration();
2826 java.util.Set parsed = new java.util.HashSet();
2827 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2828 {
2829 if ( checkFieldWithDuplicate( xmlStreamReader, "repository", null, parsed ) )
2830 {
2831 String value = xmlStreamReader.getAttributeValue( null, "id" );
2832 if ( value != null )
2833 {
2834
2835 if ( localRepositoryReferences == null )
2836 {
2837 localRepositoryReferences = new java.util.HashMap();
2838 }
2839 java.util.Map refs = (java.util.Map) localRepositoryReferences.get( repositoryPurgeConfiguration );
2840 if ( refs == null )
2841 {
2842 refs = new java.util.HashMap();
2843 localRepositoryReferences.put( repositoryPurgeConfiguration, refs );
2844 }
2845 refs.put( "repository", value );
2846 }
2847 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
2848 {
2849 xmlStreamReader.next();
2850 }
2851 }
2852 else if ( checkFieldWithDuplicate( xmlStreamReader, "deleteReleasedSnapshots", null, parsed ) )
2853 {
2854 repositoryPurgeConfiguration.setDeleteReleasedSnapshots( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "deleteReleasedSnapshots", xmlStreamReader ) );
2855 }
2856 else if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
2857 {
2858 repositoryPurgeConfiguration.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
2859 }
2860 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
2861 {
2862 repositoryPurgeConfiguration.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
2863 }
2864 else if ( checkFieldWithDuplicate( xmlStreamReader, "deleteAll", null, parsed ) )
2865 {
2866 repositoryPurgeConfiguration.setDeleteAll( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "deleteAll", xmlStreamReader ) );
2867 }
2868 else if ( checkFieldWithDuplicate( xmlStreamReader, "retentionCount", null, parsed ) )
2869 {
2870 repositoryPurgeConfiguration.setRetentionCount( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "2" ) ), "retentionCount", xmlStreamReader, strict ) );
2871 }
2872 else if ( checkFieldWithDuplicate( xmlStreamReader, "daysOlder", null, parsed ) )
2873 {
2874 repositoryPurgeConfiguration.setDaysOlder( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "100" ) ), "daysOlder", xmlStreamReader, strict ) );
2875 }
2876 else if ( checkFieldWithDuplicate( xmlStreamReader, "enabled", null, parsed ) )
2877 {
2878 repositoryPurgeConfiguration.setEnabled( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "enabled", xmlStreamReader ) );
2879 }
2880 else if ( checkFieldWithDuplicate( xmlStreamReader, "schedule", null, parsed ) )
2881 {
2882 String value = xmlStreamReader.getAttributeValue( null, "id" );
2883 if ( value != null )
2884 {
2885
2886 if ( scheduleReferences == null )
2887 {
2888 scheduleReferences = new java.util.HashMap();
2889 }
2890 java.util.Map refs = (java.util.Map) scheduleReferences.get( repositoryPurgeConfiguration );
2891 if ( refs == null )
2892 {
2893 refs = new java.util.HashMap();
2894 scheduleReferences.put( repositoryPurgeConfiguration, refs );
2895 }
2896 refs.put( "schedule", value );
2897 }
2898 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
2899 {
2900 xmlStreamReader.next();
2901 }
2902 }
2903 else if ( checkFieldWithDuplicate( xmlStreamReader, "defaultPurge", null, parsed ) )
2904 {
2905 repositoryPurgeConfiguration.setDefaultPurge( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "defaultPurge", xmlStreamReader ) );
2906 }
2907 else
2908 {
2909 if ( strict )
2910 {
2911 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
2912 }
2913 else
2914 {
2915 int unrecognizedTagCount = 1;
2916 while( unrecognizedTagCount != 0 )
2917 {
2918 xmlStreamReader.next();
2919 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
2920 {
2921 unrecognizedTagCount++;
2922 }
2923 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
2924 {
2925 unrecognizedTagCount--;
2926 }
2927 }
2928 }
2929 }
2930 }
2931 return repositoryPurgeConfiguration;
2932 }
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945 private Schedule parseSchedule( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
2946 throws IOException, XMLStreamException
2947 {
2948 Schedule schedule = new Schedule();
2949 java.util.Set parsed = new java.util.HashSet();
2950 if ( scheduleInstances == null )
2951 {
2952 scheduleInstances = new java.util.HashMap();
2953 }
2954 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
2955 if ( v != null )
2956 {
2957 scheduleInstances.put( v, schedule );
2958 }
2959 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2960 {
2961 if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
2962 {
2963 schedule.setId( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "id", xmlStreamReader, strict ) );
2964 }
2965 else if ( checkFieldWithDuplicate( xmlStreamReader, "active", null, parsed ) )
2966 {
2967 schedule.setActive( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "active", xmlStreamReader ) );
2968 }
2969 else if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
2970 {
2971 schedule.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
2972 }
2973 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
2974 {
2975 schedule.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
2976 }
2977 else if ( checkFieldWithDuplicate( xmlStreamReader, "delay", null, parsed ) )
2978 {
2979 schedule.setDelay( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "delay", xmlStreamReader, strict ) );
2980 }
2981 else if ( checkFieldWithDuplicate( xmlStreamReader, "maxJobExecutionTime", null, parsed ) )
2982 {
2983 schedule.setMaxJobExecutionTime( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "3600" ) ), "maxJobExecutionTime", xmlStreamReader, strict ) );
2984 }
2985 else if ( checkFieldWithDuplicate( xmlStreamReader, "cronExpression", null, parsed ) )
2986 {
2987 schedule.setCronExpression( getTrimmedValue( xmlStreamReader.getElementText() ) );
2988 }
2989 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildQueues", null, parsed ) )
2990 {
2991 java.util.List buildQueues = new java.util.ArrayList
2992 schedule.setBuildQueues( buildQueues );
2993 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
2994 {
2995 if ( xmlStreamReader.getLocalName().equals( "buildQueue" ) )
2996 {
2997 String value = xmlStreamReader.getAttributeValue( null, "id" );
2998 if ( value != null )
2999 {
3000
3001 if ( buildQueueReferences == null )
3002 {
3003 buildQueueReferences = new java.util.HashMap();
3004 }
3005 java.util.Map refs = (java.util.Map) buildQueueReferences.get( schedule );
3006 if ( refs == null )
3007 {
3008 refs = new java.util.HashMap();
3009 buildQueueReferences.put( schedule, refs );
3010 }
3011 refs.put( "buildQueues." + buildQueues.size(), value );
3012 }
3013 schedule.addBuildQueue( parseBuildQueue( "buildQueue", xmlStreamReader, strict, encoding ) );
3014 }
3015 else
3016 {
3017 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
3018 }
3019 }
3020 }
3021 else
3022 {
3023 if ( strict )
3024 {
3025 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
3026 }
3027 else
3028 {
3029 int unrecognizedTagCount = 1;
3030 while( unrecognizedTagCount != 0 )
3031 {
3032 xmlStreamReader.next();
3033 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
3034 {
3035 unrecognizedTagCount++;
3036 }
3037 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
3038 {
3039 unrecognizedTagCount--;
3040 }
3041 }
3042 }
3043 }
3044 }
3045 scheduleInstances.put( String.valueOf( schedule.getId() ), schedule );
3046 return schedule;
3047 }
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060 private ScmResult parseScmResult( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
3061 throws IOException, XMLStreamException
3062 {
3063 ScmResult scmResult = new ScmResult();
3064 java.util.Set parsed = new java.util.HashSet();
3065 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
3066 {
3067 if ( checkFieldWithDuplicate( xmlStreamReader, "success", null, parsed ) )
3068 {
3069 scmResult.setSuccess( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "success", xmlStreamReader ) );
3070 }
3071 else if ( checkFieldWithDuplicate( xmlStreamReader, "commandLine", null, parsed ) )
3072 {
3073 scmResult.setCommandLine( getTrimmedValue( xmlStreamReader.getElementText() ) );
3074 }
3075 else if ( checkFieldWithDuplicate( xmlStreamReader, "providerMessage", null, parsed ) )
3076 {
3077 scmResult.setProviderMessage( getTrimmedValue( xmlStreamReader.getElementText() ) );
3078 }
3079 else if ( checkFieldWithDuplicate( xmlStreamReader, "commandOutput", null, parsed ) )
3080 {
3081 scmResult.setCommandOutput( getTrimmedValue( xmlStreamReader.getElementText() ) );
3082 }
3083 else if ( checkFieldWithDuplicate( xmlStreamReader, "exception", null, parsed ) )
3084 {
3085 scmResult.setException( getTrimmedValue( xmlStreamReader.getElementText() ) );
3086 }
3087 else if ( checkFieldWithDuplicate( xmlStreamReader, "changes", null, parsed ) )
3088 {
3089 java.util.List changes = new java.util.ArrayList
3090 scmResult.setChanges( changes );
3091 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
3092 {
3093 if ( xmlStreamReader.getLocalName().equals( "change" ) )
3094 {
3095 scmResult.addChange( parseChangeSet( "change", xmlStreamReader, strict, encoding ) );
3096 }
3097 else
3098 {
3099 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
3100 }
3101 }
3102 }
3103 else
3104 {
3105 if ( strict )
3106 {
3107 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
3108 }
3109 else
3110 {
3111 int unrecognizedTagCount = 1;
3112 while( unrecognizedTagCount != 0 )
3113 {
3114 xmlStreamReader.next();
3115 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
3116 {
3117 unrecognizedTagCount++;
3118 }
3119 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
3120 {
3121 unrecognizedTagCount--;
3122 }
3123 }
3124 }
3125 }
3126 }
3127 return scmResult;
3128 }
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141 private SystemConfiguration parseSystemConfiguration( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
3142 throws IOException, XMLStreamException
3143 {
3144 SystemConfiguration systemConfiguration = new SystemConfiguration();
3145 java.util.Set parsed = new java.util.HashSet();
3146 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
3147 {
3148 if ( checkFieldWithDuplicate( xmlStreamReader, "guestAccountEnabled", null, parsed ) )
3149 {
3150 systemConfiguration.setGuestAccountEnabled( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "guestAccountEnabled", xmlStreamReader ) );
3151 }
3152 else if ( checkFieldWithDuplicate( xmlStreamReader, "defaultScheduleDescription", null, parsed ) )
3153 {
3154 systemConfiguration.setDefaultScheduleDescription( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "Run hourly" ) ) );
3155 }
3156 else if ( checkFieldWithDuplicate( xmlStreamReader, "defaultScheduleCronExpression", null, parsed ) )
3157 {
3158 systemConfiguration.setDefaultScheduleCronExpression( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0 0 * * * ?" ) ) );
3159 }
3160 else if ( checkFieldWithDuplicate( xmlStreamReader, "workingDirectory", null, parsed ) )
3161 {
3162 systemConfiguration.setWorkingDirectory( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "working-directory" ) ) );
3163 }
3164 else if ( checkFieldWithDuplicate( xmlStreamReader, "buildOutputDirectory", null, parsed ) )
3165 {
3166 systemConfiguration.setBuildOutputDirectory( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "build-output-directory" ) ) );
3167 }
3168 else if ( checkFieldWithDuplicate( xmlStreamReader, "deploymentRepositoryDirectory", null, parsed ) )
3169 {
3170 systemConfiguration.setDeploymentRepositoryDirectory( getTrimmedValue( xmlStreamReader.getElementText() ) );
3171 }
3172 else if ( checkFieldWithDuplicate( xmlStreamReader, "baseUrl", null, parsed ) )
3173 {
3174 systemConfiguration.setBaseUrl( getTrimmedValue( xmlStreamReader.getElementText() ) );
3175 }
3176 else if ( checkFieldWithDuplicate( xmlStreamReader, "initialized", null, parsed ) )
3177 {
3178 systemConfiguration.setInitialized( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "initialized", xmlStreamReader ) );
3179 }
3180 else if ( checkFieldWithDuplicate( xmlStreamReader, "releaseOutputDirectory", null, parsed ) )
3181 {
3182 systemConfiguration.setReleaseOutputDirectory( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "release-output-directory" ) ) );
3183 }
3184 else if ( checkFieldWithDuplicate( xmlStreamReader, "numberOfBuildsInParallel", null, parsed ) )
3185 {
3186 systemConfiguration.setNumberOfBuildsInParallel( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "1" ) ), "numberOfBuildsInParallel", xmlStreamReader, strict ) );
3187 }
3188 else if ( checkFieldWithDuplicate( xmlStreamReader, "distributedBuildEnabled", null, parsed ) )
3189 {
3190 systemConfiguration.setDistributedBuildEnabled( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "distributedBuildEnabled", xmlStreamReader ) );
3191 }
3192 else
3193 {
3194 if ( strict )
3195 {
3196 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
3197 }
3198 else
3199 {
3200 int unrecognizedTagCount = 1;
3201 while( unrecognizedTagCount != 0 )
3202 {
3203 xmlStreamReader.next();
3204 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
3205 {
3206 unrecognizedTagCount++;
3207 }
3208 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
3209 {
3210 unrecognizedTagCount--;
3211 }
3212 }
3213 }
3214 }
3215 }
3216 return systemConfiguration;
3217 }
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228 public ContinuumDatabase read( Reader reader, boolean strict )
3229 throws IOException, XMLStreamException
3230 {
3231 XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( reader );
3232
3233 String encoding = xmlStreamReader.getCharacterEncodingScheme();
3234 ContinuumDatabase value = parseContinuumDatabase( "continuumDatabase", xmlStreamReader, strict, encoding );
3235 resolveReferences( value );
3236 return value;
3237 }
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247 public ContinuumDatabase read( Reader reader )
3248 throws IOException, XMLStreamException
3249 {
3250 return read( reader, true );
3251 }
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262 public ContinuumDatabase read( String filePath, boolean strict )
3263 throws IOException, XMLStreamException
3264 {
3265 File file = new File(filePath);
3266 XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( file.toURL().toExternalForm(), new FileInputStream(file) );
3267
3268 String encoding = xmlStreamReader.getCharacterEncodingScheme();
3269 ContinuumDatabase value = parseContinuumDatabase( "continuumDatabase", xmlStreamReader, strict, encoding );
3270 resolveReferences( value );
3271 return value;
3272 }
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282 public ContinuumDatabase read( String filePath )
3283 throws IOException, XMLStreamException
3284 {
3285 return read( filePath, true );
3286 }
3287
3288
3289
3290
3291
3292
3293 private void resolveReferences( ContinuumDatabase value )
3294 {
3295 java.util.Map refs;
3296 for ( java.util.Iterator i = value.getProjectGroups().iterator(); i.hasNext(); )
3297 {
3298 resolveReferences( (ProjectGroup) i.next() );
3299 }
3300 for ( java.util.Iterator i = value.getSchedules().iterator(); i.hasNext(); )
3301 {
3302 resolveReferences( (Schedule) i.next() );
3303 }
3304 for ( java.util.Iterator i = value.getProfiles().iterator(); i.hasNext(); )
3305 {
3306 resolveReferences( (Profile) i.next() );
3307 }
3308 for ( java.util.Iterator i = value.getRepositoryPurgeConfigurations().iterator(); i.hasNext(); )
3309 {
3310 resolveReferences( (RepositoryPurgeConfiguration) i.next() );
3311 }
3312 for ( java.util.Iterator i = value.getDirectoryPurgeConfigurations().iterator(); i.hasNext(); )
3313 {
3314 resolveReferences( (DirectoryPurgeConfiguration) i.next() );
3315 }
3316 for ( java.util.Iterator i = value.getProjectScmRoots().iterator(); i.hasNext(); )
3317 {
3318 resolveReferences( (ProjectScmRoot) i.next() );
3319 }
3320 for ( java.util.Iterator i = value.getContinuumReleaseResults().iterator(); i.hasNext(); )
3321 {
3322 resolveReferences( (ContinuumReleaseResult) i.next() );
3323 }
3324 for ( java.util.Iterator i = value.getBuildDefinitionTemplates().iterator(); i.hasNext(); )
3325 {
3326 resolveReferences( (BuildDefinitionTemplate) i.next() );
3327 }
3328 for ( java.util.Iterator i = value.getBuildDefinitions().iterator(); i.hasNext(); )
3329 {
3330 resolveReferences( (BuildDefinition) i.next() );
3331 }
3332 }
3333
3334
3335
3336
3337
3338
3339 private void resolveReferences( ProjectGroup value )
3340 {
3341 java.util.Map refs;
3342 for ( java.util.Iterator i = value.getProjects().iterator(); i.hasNext(); )
3343 {
3344 resolveReferences( (Project) i.next() );
3345 }
3346 for ( java.util.Iterator i = value.getBuildDefinitions().iterator(); i.hasNext(); )
3347 {
3348 resolveReferences( (BuildDefinition) i.next() );
3349 }
3350 if ( localRepositoryReferences != null )
3351 {
3352 refs = (java.util.Map) localRepositoryReferences.get( value );
3353 if ( refs != null )
3354 {
3355 String id = (String) refs.get( "localRepository" );
3356 LocalRepository ref = (LocalRepository) localRepositoryInstances.get( id );
3357 if ( ref != null && !ref.equals( value.getLocalRepository() ) )
3358 {
3359 value.setLocalRepository( ref );
3360 }
3361 }
3362 }
3363 }
3364
3365
3366
3367
3368
3369
3370 private void resolveReferences( ContinuumReleaseResult value )
3371 {
3372 java.util.Map refs;
3373 if ( projectGroupReferences != null )
3374 {
3375 refs = (java.util.Map) projectGroupReferences.get( value );
3376 if ( refs != null )
3377 {
3378 String id = (String) refs.get( "projectGroup" );
3379 ProjectGroup ref = (ProjectGroup) projectGroupInstances.get( id );
3380 if ( ref != null && !ref.equals( value.getProjectGroup() ) )
3381 {
3382 value.setProjectGroup( ref );
3383 }
3384 }
3385 }
3386 if ( projectReferences != null )
3387 {
3388 refs = (java.util.Map) projectReferences.get( value );
3389 if ( refs != null )
3390 {
3391 String id = (String) refs.get( "project" );
3392 Project ref = (Project) projectInstances.get( id );
3393 if ( ref != null && !ref.equals( value.getProject() ) )
3394 {
3395 value.setProject( ref );
3396 }
3397 }
3398 }
3399 }
3400
3401
3402
3403
3404
3405
3406 private void resolveReferences( Schedule value )
3407 {
3408 java.util.Map refs;
3409 if ( buildQueueReferences != null )
3410 {
3411 refs = (java.util.Map) buildQueueReferences.get( value );
3412 if ( refs != null )
3413 {
3414 for ( int i = 0; i < value.getBuildQueues().size(); i++ )
3415 {
3416 String id = (String) refs.get( "buildQueues." + i );
3417 BuildQueue ref = (BuildQueue) buildQueueInstances.get( id );
3418 if ( ref != null )
3419 {
3420 value.getBuildQueues().set( i, ref );
3421 }
3422 }
3423 }
3424 }
3425 }
3426
3427
3428
3429
3430
3431
3432 private void resolveReferences( BuildDefinitionTemplate value )
3433 {
3434 java.util.Map refs;
3435 if ( buildDefinitionReferences != null )
3436 {
3437 refs = (java.util.Map) buildDefinitionReferences.get( value );
3438 if ( refs != null )
3439 {
3440 for ( int i = 0; i < value.getBuildDefinitions().size(); i++ )
3441 {
3442 String id = (String) refs.get( "buildDefinitions." + i );
3443 BuildDefinition ref = (BuildDefinition) buildDefinitionInstances.get( id );
3444 if ( ref != null )
3445 {
3446 value.getBuildDefinitions().set( i, ref );
3447 }
3448 }
3449 }
3450 }
3451 }
3452
3453
3454
3455
3456
3457
3458 private void resolveReferences( BuildDefinition value )
3459 {
3460 java.util.Map refs;
3461 if ( scheduleReferences != null )
3462 {
3463 refs = (java.util.Map) scheduleReferences.get( value );
3464 if ( refs != null )
3465 {
3466 String id = (String) refs.get( "schedule" );
3467 Schedule ref = (Schedule) scheduleInstances.get( id );
3468 if ( ref != null && !ref.equals( value.getSchedule() ) )
3469 {
3470 value.setSchedule( ref );
3471 }
3472 }
3473 }
3474 if ( profileReferences != null )
3475 {
3476 refs = (java.util.Map) profileReferences.get( value );
3477 if ( refs != null )
3478 {
3479 String id = (String) refs.get( "profile" );
3480 Profile ref = (Profile) profileInstances.get( id );
3481 if ( ref != null && !ref.equals( value.getProfile() ) )
3482 {
3483 value.setProfile( ref );
3484 }
3485 }
3486 }
3487 }
3488
3489
3490
3491
3492
3493
3494 private void resolveReferences( ProjectScmRoot value )
3495 {
3496 java.util.Map refs;
3497 if ( projectGroupReferences != null )
3498 {
3499 refs = (java.util.Map) projectGroupReferences.get( value );
3500 if ( refs != null )
3501 {
3502 String id = (String) refs.get( "projectGroup" );
3503 ProjectGroup ref = (ProjectGroup) projectGroupInstances.get( id );
3504 if ( ref != null && !ref.equals( value.getProjectGroup() ) )
3505 {
3506 value.setProjectGroup( ref );
3507 }
3508 }
3509 }
3510 }
3511
3512
3513
3514
3515
3516
3517 private void resolveReferences( DirectoryPurgeConfiguration value )
3518 {
3519 java.util.Map refs;
3520 if ( scheduleReferences != null )
3521 {
3522 refs = (java.util.Map) scheduleReferences.get( value );
3523 if ( refs != null )
3524 {
3525 String id = (String) refs.get( "schedule" );
3526 Schedule ref = (Schedule) scheduleInstances.get( id );
3527 if ( ref != null && !ref.equals( value.getSchedule() ) )
3528 {
3529 value.setSchedule( ref );
3530 }
3531 }
3532 }
3533 }
3534
3535
3536
3537
3538
3539
3540 private void resolveReferences( Profile value )
3541 {
3542 java.util.Map refs;
3543 if ( installationReferences != null )
3544 {
3545 refs = (java.util.Map) installationReferences.get( value );
3546 if ( refs != null )
3547 {
3548 String id = (String) refs.get( "jdk" );
3549 Installation ref = (Installation) installationInstances.get( id );
3550 if ( ref != null && !ref.equals( value.getJdk() ) )
3551 {
3552 value.setJdk( ref );
3553 }
3554 }
3555 }
3556 if ( installationReferences != null )
3557 {
3558 refs = (java.util.Map) installationReferences.get( value );
3559 if ( refs != null )
3560 {
3561 String id = (String) refs.get( "builder" );
3562 Installation ref = (Installation) installationInstances.get( id );
3563 if ( ref != null && !ref.equals( value.getBuilder() ) )
3564 {
3565 value.setBuilder( ref );
3566 }
3567 }
3568 }
3569 if ( installationReferences != null )
3570 {
3571 refs = (java.util.Map) installationReferences.get( value );
3572 if ( refs != null )
3573 {
3574 for ( int i = 0; i < value.getEnvironmentVariables().size(); i++ )
3575 {
3576 String id = (String) refs.get( "environmentVariables." + i );
3577 Installation ref = (Installation) installationInstances.get( id );
3578 if ( ref != null )
3579 {
3580 value.getEnvironmentVariables().set( i, ref );
3581 }
3582 }
3583 }
3584 }
3585 }
3586
3587
3588
3589
3590
3591
3592 private void resolveReferences( Project value )
3593 {
3594 java.util.Map refs;
3595 for ( java.util.Iterator i = value.getBuildResults().iterator(); i.hasNext(); )
3596 {
3597 resolveReferences( (BuildResult) i.next() );
3598 }
3599 if ( projectGroupReferences != null )
3600 {
3601 refs = (java.util.Map) projectGroupReferences.get( value );
3602 if ( refs != null )
3603 {
3604 String id = (String) refs.get( "projectGroup" );
3605 ProjectGroup ref = (ProjectGroup) projectGroupInstances.get( id );
3606 if ( ref != null && !ref.equals( value.getProjectGroup() ) )
3607 {
3608 value.setProjectGroup( ref );
3609 }
3610 }
3611 }
3612 for ( java.util.Iterator i = value.getBuildDefinitions().iterator(); i.hasNext(); )
3613 {
3614 resolveReferences( (BuildDefinition) i.next() );
3615 }
3616 }
3617
3618
3619
3620
3621
3622
3623 private void resolveReferences( BuildResult value )
3624 {
3625 java.util.Map refs;
3626 if ( projectReferences != null )
3627 {
3628 refs = (java.util.Map) projectReferences.get( value );
3629 if ( refs != null )
3630 {
3631 String id = (String) refs.get( "project" );
3632 Project ref = (Project) projectInstances.get( id );
3633 if ( ref != null && !ref.equals( value.getProject() ) )
3634 {
3635 value.setProject( ref );
3636 }
3637 }
3638 }
3639 if ( buildDefinitionReferences != null )
3640 {
3641 refs = (java.util.Map) buildDefinitionReferences.get( value );
3642 if ( refs != null )
3643 {
3644 String id = (String) refs.get( "buildDefinition" );
3645 BuildDefinition ref = (BuildDefinition) buildDefinitionInstances.get( id );
3646 if ( ref != null && !ref.equals( value.getBuildDefinition() ) )
3647 {
3648 value.setBuildDefinition( ref );
3649 }
3650 }
3651 }
3652 }
3653
3654
3655
3656
3657
3658
3659 private void resolveReferences( RepositoryPurgeConfiguration value )
3660 {
3661 java.util.Map refs;
3662 if ( localRepositoryReferences != null )
3663 {
3664 refs = (java.util.Map) localRepositoryReferences.get( value );
3665 if ( refs != null )
3666 {
3667 String id = (String) refs.get( "repository" );
3668 LocalRepository ref = (LocalRepository) localRepositoryInstances.get( id );
3669 if ( ref != null && !ref.equals( value.getRepository() ) )
3670 {
3671 value.setRepository( ref );
3672 }
3673 }
3674 }
3675 if ( scheduleReferences != null )
3676 {
3677 refs = (java.util.Map) scheduleReferences.get( value );
3678 if ( refs != null )
3679 {
3680 String id = (String) refs.get( "schedule" );
3681 Schedule ref = (Schedule) scheduleInstances.get( id );
3682 if ( ref != null && !ref.equals( value.getSchedule() ) )
3683 {
3684 value.setSchedule( ref );
3685 }
3686 }
3687 }
3688 }
3689
3690 }