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