GC: CTCrsCatalogueType - net.opengis.iso19139.gmx.v_20060504.CTCrsCatalogueType (.java)

Maven-Central
/
org.jvnet.ogc / iso19139-v_20060504
/
2.1.0

2.2.0
2.1.0
/
net.opengis.iso19139.gmx.v_20060504.CTCrsCatalogueType
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
   //
2
   // This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.11 
3
   // See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
4
   // Any modifications to this file will be lost upon recompilation of the source schema. 
5
   // Generated on: 2015.03.28 at 10:20:34 AM CET 
6
   //
7
   
8
   
9
   package net.opengis.iso19139.gmx.v_20060504;
10
  
11
  import java.util.ArrayList;
12
  import java.util.Collection;
13
  import java.util.List;
14
  import javax.xml.bind.annotation.XmlAccessType;
15
  import javax.xml.bind.annotation.XmlAccessorType;
16
  import javax.xml.bind.annotation.XmlElement;
17
  import javax.xml.bind.annotation.XmlType;
18
  import net.opengis.iso19139.gco.v_20060504.CharacterStringPropertyType;
19
  import net.opengis.iso19139.gco.v_20060504.DatePropertyType;
20
  import net.opengis.iso19139.gmd.v_20060504.MDCharacterSetCodePropertyType;
21
  import net.opengis.iso19139.gmd.v_20060504.PTLocalePropertyType;
22
  import org.jvnet.jaxb2_commons.lang.CopyStrategy;
23
  import org.jvnet.jaxb2_commons.lang.CopyTo;
24
  import org.jvnet.jaxb2_commons.lang.Equals;
25
  import org.jvnet.jaxb2_commons.lang.EqualsStrategy;
26
  import org.jvnet.jaxb2_commons.lang.HashCode;
27
  import org.jvnet.jaxb2_commons.lang.HashCodeStrategy;
28
  import org.jvnet.jaxb2_commons.lang.JAXBCopyStrategy;
29
  import org.jvnet.jaxb2_commons.lang.JAXBEqualsStrategy;
30
  import org.jvnet.jaxb2_commons.lang.JAXBHashCodeStrategy;
31
  import org.jvnet.jaxb2_commons.lang.JAXBMergeStrategy;
32
  import org.jvnet.jaxb2_commons.lang.JAXBToStringStrategy;
33
  import org.jvnet.jaxb2_commons.lang.MergeFrom;
34
  import org.jvnet.jaxb2_commons.lang.MergeStrategy;
35
  import org.jvnet.jaxb2_commons.lang.ToString;
36
  import org.jvnet.jaxb2_commons.lang.ToStringStrategy;
37
  import org.jvnet.jaxb2_commons.locator.ObjectLocator;
38
  import org.jvnet.jaxb2_commons.locator.util.LocatorUtils;


Java class for CT_CrsCatalogue_Type complex type.
 
 
The following schema fragment specifies the expected content contained within this class.
 
 
 <complexType name="CT_CrsCatalogue_Type">
   <complexContent>
     <extension base="{http://www.isotc211.org/2005/gmx}AbstractCT_Catalogue_Type">
       <sequence>
         <element name="crs" type="{http://www.isotc211.org/2005/gmx}CT_CRS_PropertyType" maxOccurs="unbounded"/>
         <element name="coordinateSystem" type="{http://www.isotc211.org/2005/gmx}CT_CoordinateSystem_PropertyType" maxOccurs="unbounded" minOccurs="0"/>
         <element name="axis" type="{http://www.isotc211.org/2005/gmx}CT_CoordinateSystemAxis_PropertyType" maxOccurs="unbounded" minOccurs="0"/>
         <element name="datum" type="{http://www.isotc211.org/2005/gmx}CT_Datum_PropertyType" maxOccurs="unbounded" minOccurs="0"/>
         <element name="ellipsoid" type="{http://www.isotc211.org/2005/gmx}CT_Ellipsoid_PropertyType" maxOccurs="unbounded" minOccurs="0"/>
         <element name="primeMeridian" type="{http://www.isotc211.org/2005/gmx}CT_PrimeMeridian_PropertyType" maxOccurs="unbounded" minOccurs="0"/>
         <element name="operation" type="{http://www.isotc211.org/2005/gmx}CT_Operation_PropertyType" maxOccurs="unbounded" minOccurs="0"/>
         <element name="operationMethod" type="{http://www.isotc211.org/2005/gmx}CT_OperationMethod_PropertyType" maxOccurs="unbounded" minOccurs="0"/>
         <element name="parameters" type="{http://www.isotc211.org/2005/gmx}CT_OperationParameters_PropertyType" maxOccurs="unbounded" minOccurs="0"/>
       </sequence>
     </extension>
   </complexContent>
 </complexType>
 
67
  
68
  @XmlAccessorType(XmlAccessType.FIELD)
69
  @XmlType(name = "CT_CrsCatalogue_Type", propOrder = {
70
      "crs",
71
      "coordinateSystem",
72
      "axis",
73
      "datum",
74
      "ellipsoid",
75
      "primeMeridian",
76
      "operation",
77
      "operationMethod",
78
      "parameters"
79
  })
80
  public class CTCrsCatalogueType
81
      extends AbstractCTCatalogueType
82
      implements Cloneable, CopyTo, Equals, HashCode, MergeFrom, ToString
83
  {
84
  
85
      @XmlElement(required = true)
86
      protected List<CTCRSPropertyType> crs;
87
      protected List<CTCoordinateSystemPropertyType> coordinateSystem;
88
      protected List<CTCoordinateSystemAxisPropertyType> axis;
89
      protected List<CTDatumPropertyType> datum;
90
      protected List<CTEllipsoidPropertyType> ellipsoid;
91
      protected List<CTPrimeMeridianPropertyType> primeMeridian;
92
      protected List<CTOperationPropertyType> operation;
93
      protected List<CTOperationMethodPropertyType> operationMethod;
94
      protected List<CTOperationParametersPropertyType> parameters;

    
 Gets the value of the crs property.
 
 
 This accessor method returns a reference to the live list,
 not a snapshot. Therefore any modification you make to the
 returned list will be present inside the JAXB object.
 This is why there is not a set method for the crs property.
 
 

 For example, to add a new item, do as follows:
 
    getCrs().add(newItem);
 
 Objects of the following type(s) are allowed in the list
 
 
 
 
117
 
118
     public List<CTCRSPropertyType> getCrs() {
119
         if (crs == null) {
120
             crs = new ArrayList<CTCRSPropertyType>();
121
         }
122
         return this.crs;
123
     }

    
 Gets the value of the coordinateSystem property.
 
 
 This accessor method returns a reference to the live list,
 not a snapshot. Therefore any modification you make to the
 returned list will be present inside the JAXB object.
 This is why there is not a set method for the coordinateSystem property.
 
 

 For example, to add a new item, do as follows:
 
    getCoordinateSystem().add(newItem);
 
 Objects of the following type(s) are allowed in the list
 
 
 
 
146
 
147
     public List<CTCoordinateSystemPropertyType> getCoordinateSystem() {
148
         if (coordinateSystem == null) {
149
             coordinateSystem = new ArrayList<CTCoordinateSystemPropertyType>();
150
         }
151
         return this.coordinateSystem;
152
     }

    
 Gets the value of the axis property.
 
 
 This accessor method returns a reference to the live list,
 not a snapshot. Therefore any modification you make to the
 returned list will be present inside the JAXB object.
 This is why there is not a set method for the axis property.
 
 

 For example, to add a new item, do as follows:
 
    getAxis().add(newItem);
 
 Objects of the following type(s) are allowed in the list
 
 
 
 
175
 
176
     public List<CTCoordinateSystemAxisPropertyType> getAxis() {
177
         if (axis == null) {
178
             axis = new ArrayList<CTCoordinateSystemAxisPropertyType>();
179
         }
180
         return this.axis;
181
     }

    
 Gets the value of the datum property.
 
 
 This accessor method returns a reference to the live list,
 not a snapshot. Therefore any modification you make to the
 returned list will be present inside the JAXB object.
 This is why there is not a set method for the datum property.
 
 

 For example, to add a new item, do as follows:
 
    getDatum().add(newItem);
 
 Objects of the following type(s) are allowed in the list
 
 
 
 
204
 
205
     public List<CTDatumPropertyType> getDatum() {
206
         if (datum == null) {
207
             datum = new ArrayList<CTDatumPropertyType>();
208
         }
209
         return this.datum;
210
     }

    
 Gets the value of the ellipsoid property.
 
 
 This accessor method returns a reference to the live list,
 not a snapshot. Therefore any modification you make to the
 returned list will be present inside the JAXB object.
 This is why there is not a set method for the ellipsoid property.
 
 

 For example, to add a new item, do as follows:
 
    getEllipsoid().add(newItem);
 
 Objects of the following type(s) are allowed in the list
 
 
 
 
233
 
234
     public List<CTEllipsoidPropertyType> getEllipsoid() {
235
         if (ellipsoid == null) {
236
             ellipsoid = new ArrayList<CTEllipsoidPropertyType>();
237
         }
238
         return this.ellipsoid;
239
     }

    
 Gets the value of the primeMeridian property.
 
 
 This accessor method returns a reference to the live list,
 not a snapshot. Therefore any modification you make to the
 returned list will be present inside the JAXB object.
 This is why there is not a set method for the primeMeridian property.
 
 

 For example, to add a new item, do as follows:
 
    getPrimeMeridian().add(newItem);
 
 Objects of the following type(s) are allowed in the list
 
 
 
 
262
 
263
     public List<CTPrimeMeridianPropertyType> getPrimeMeridian() {
264
         if (primeMeridian == null) {
265
             primeMeridian = new ArrayList<CTPrimeMeridianPropertyType>();
266
         }
267
         return this.primeMeridian;
268
     }

    
 Gets the value of the operation property.
 
 
 This accessor method returns a reference to the live list,
 not a snapshot. Therefore any modification you make to the
 returned list will be present inside the JAXB object.
 This is why there is not a set method for the operation property.
 
 

 For example, to add a new item, do as follows:
 
    getOperation().add(newItem);
 
 Objects of the following type(s) are allowed in the list
 
 
 
 
291
 
292
     public List<CTOperationPropertyType> getOperation() {
293
         if (operation == null) {
294
             operation = new ArrayList<CTOperationPropertyType>();
295
         }
296
         return this.operation;
297
     }

    
 Gets the value of the operationMethod property.
 
 
 This accessor method returns a reference to the live list,
 not a snapshot. Therefore any modification you make to the
 returned list will be present inside the JAXB object.
 This is why there is not a set method for the operationMethod property.
 
 

 For example, to add a new item, do as follows:
 
    getOperationMethod().add(newItem);
 
 Objects of the following type(s) are allowed in the list
 
 
 
 
320
 
321
     public List<CTOperationMethodPropertyType> getOperationMethod() {
322
         if (operationMethod == null) {
323
             operationMethod = new ArrayList<CTOperationMethodPropertyType>();
324
         }
325
         return this.operationMethod;
326
     }

    
 Gets the value of the parameters property.
 
 
 This accessor method returns a reference to the live list,
 not a snapshot. Therefore any modification you make to the
 returned list will be present inside the JAXB object.
 This is why there is not a set method for the parameters property.
 
 

 For example, to add a new item, do as follows:
 
    getParameters().add(newItem);
 
 Objects of the following type(s) are allowed in the list
 
 
 
 
349
 
350
     public List<CTOperationParametersPropertyType> getParameters() {
351
         if (parameters == null) {
352
             parameters = new ArrayList<CTOperationParametersPropertyType>();
353
         }
354
         return this.parameters;
355
     }
356
 
357
     public String toString() {
358
         final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE;
359
         final StringBuilder buffer = new StringBuilder();
360
         append(null, buffer, strategy);
361
         return buffer.toString();
362
     }
363
 
364
     public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) {
365
         strategy.appendStart(locator, this, buffer);
366
         appendFields(locator, buffer, strategy);
367
         strategy.appendEnd(locator, this, buffer);
368
         return buffer;
369
     }
370
 
371
     public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) {
372
         super.appendFields(locator, buffer, strategy);
373
         {
374
             List<CTCRSPropertyType> theCrs;
375
             theCrs = (((this.crs!= null)&&(!this.crs.isEmpty()))?this.getCrs():null);
376
             strategy.appendField(locator, this, "crs", buffer, theCrs);
377
         }
378
         {
379
             List<CTCoordinateSystemPropertyType> theCoordinateSystem;
380
             theCoordinateSystem = (((this.coordinateSystem!= null)&&(!this.coordinateSystem.isEmpty()))?this.getCoordinateSystem():null);
381
             strategy.appendField(locator, this, "coordinateSystem", buffer, theCoordinateSystem);
382
         }
383
         {
384
             List<CTCoordinateSystemAxisPropertyType> theAxis;
385
             theAxis = (((this.axis!= null)&&(!this.axis.isEmpty()))?this.getAxis():null);
386
             strategy.appendField(locator, this, "axis", buffer, theAxis);
387
         }
388
         {
389
             List<CTDatumPropertyType> theDatum;
390
             theDatum = (((this.datum!= null)&&(!this.datum.isEmpty()))?this.getDatum():null);
391
             strategy.appendField(locator, this, "datum", buffer, theDatum);
392
         }
393
         {
394
             List<CTEllipsoidPropertyType> theEllipsoid;
395
             theEllipsoid = (((this.ellipsoid!= null)&&(!this.ellipsoid.isEmpty()))?this.getEllipsoid():null);
396
             strategy.appendField(locator, this, "ellipsoid", buffer, theEllipsoid);
397
         }
398
         {
399
             List<CTPrimeMeridianPropertyType> thePrimeMeridian;
400
             thePrimeMeridian = (((this.primeMeridian!= null)&&(!this.primeMeridian.isEmpty()))?this.getPrimeMeridian():null);
401
             strategy.appendField(locator, this, "primeMeridian", buffer, thePrimeMeridian);
402
         }
403
         {
404
             List<CTOperationPropertyType> theOperation;
405
             theOperation = (((this.operation!= null)&&(!this.operation.isEmpty()))?this.getOperation():null);
406
             strategy.appendField(locator, this, "operation", buffer, theOperation);
407
         }
408
         {
409
             List<CTOperationMethodPropertyType> theOperationMethod;
410
             theOperationMethod = (((this.operationMethod!= null)&&(!this.operationMethod.isEmpty()))?this.getOperationMethod():null);
411
             strategy.appendField(locator, this, "operationMethod", buffer, theOperationMethod);
412
         }
413
         {
414
             List<CTOperationParametersPropertyType> theParameters;
415
             theParameters = (((this.parameters!= null)&&(!this.parameters.isEmpty()))?this.getParameters():null);
416
             strategy.appendField(locator, this, "parameters", buffer, theParameters);
417
         }
418
         return buffer;
419
     }
420
 
421
     public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) {
422
         if (!(object instanceof CTCrsCatalogueType)) {
423
             return false;
424
         }
425
         if (this == object) {
426
             return true;
427
         }
428
         if (!super.equals(thisLocator, thatLocator, object, strategy)) {
429
             return false;
430
         }
431
         final CTCrsCatalogueType that = ((CTCrsCatalogueType) object);
432
         {
433
             List<CTCRSPropertyType> lhsCrs;
434
             lhsCrs = (((this.crs!= null)&&(!this.crs.isEmpty()))?this.getCrs():null);
435
             List<CTCRSPropertyType> rhsCrs;
436
             rhsCrs = (((that.crs!= null)&&(!that.crs.isEmpty()))?that.getCrs():null);
437
             if (!strategy.equals(LocatorUtils.property(thisLocator, "crs", lhsCrs), LocatorUtils.property(thatLocator, "crs", rhsCrs), lhsCrs, rhsCrs)) {
438
                 return false;
439
             }
440
         }
441
         {
442
             List<CTCoordinateSystemPropertyType> lhsCoordinateSystem;
443
             lhsCoordinateSystem = (((this.coordinateSystem!= null)&&(!this.coordinateSystem.isEmpty()))?this.getCoordinateSystem():null);
444
             List<CTCoordinateSystemPropertyType> rhsCoordinateSystem;
445
             rhsCoordinateSystem = (((that.coordinateSystem!= null)&&(!that.coordinateSystem.isEmpty()))?that.getCoordinateSystem():null);
446
             if (!strategy.equals(LocatorUtils.property(thisLocator, "coordinateSystem", lhsCoordinateSystem), LocatorUtils.property(thatLocator, "coordinateSystem", rhsCoordinateSystem), lhsCoordinateSystem, rhsCoordinateSystem)) {
447
                 return false;
448
             }
449
         }
450
         {
451
             List<CTCoordinateSystemAxisPropertyType> lhsAxis;
452
             lhsAxis = (((this.axis!= null)&&(!this.axis.isEmpty()))?this.getAxis():null);
453
             List<CTCoordinateSystemAxisPropertyType> rhsAxis;
454
             rhsAxis = (((that.axis!= null)&&(!that.axis.isEmpty()))?that.getAxis():null);
455
             if (!strategy.equals(LocatorUtils.property(thisLocator, "axis", lhsAxis), LocatorUtils.property(thatLocator, "axis", rhsAxis), lhsAxis, rhsAxis)) {
456
                 return false;
457
             }
458
         }
459
         {
460
             List<CTDatumPropertyType> lhsDatum;
461
             lhsDatum = (((this.datum!= null)&&(!this.datum.isEmpty()))?this.getDatum():null);
462
             List<CTDatumPropertyType> rhsDatum;
463
             rhsDatum = (((that.datum!= null)&&(!that.datum.isEmpty()))?that.getDatum():null);
464
             if (!strategy.equals(LocatorUtils.property(thisLocator, "datum", lhsDatum), LocatorUtils.property(thatLocator, "datum", rhsDatum), lhsDatum, rhsDatum)) {
465
                 return false;
466
             }
467
         }
468
         {
469
             List<CTEllipsoidPropertyType> lhsEllipsoid;
470
             lhsEllipsoid = (((this.ellipsoid!= null)&&(!this.ellipsoid.isEmpty()))?this.getEllipsoid():null);
471
             List<CTEllipsoidPropertyType> rhsEllipsoid;
472
             rhsEllipsoid = (((that.ellipsoid!= null)&&(!that.ellipsoid.isEmpty()))?that.getEllipsoid():null);
473
             if (!strategy.equals(LocatorUtils.property(thisLocator, "ellipsoid", lhsEllipsoid), LocatorUtils.property(thatLocator, "ellipsoid", rhsEllipsoid), lhsEllipsoid, rhsEllipsoid)) {
474
                 return false;
475
             }
476
         }
477
         {
478
             List<CTPrimeMeridianPropertyType> lhsPrimeMeridian;
479
             lhsPrimeMeridian = (((this.primeMeridian!= null)&&(!this.primeMeridian.isEmpty()))?this.getPrimeMeridian():null);
480
             List<CTPrimeMeridianPropertyType> rhsPrimeMeridian;
481
             rhsPrimeMeridian = (((that.primeMeridian!= null)&&(!that.primeMeridian.isEmpty()))?that.getPrimeMeridian():null);
482
             if (!strategy.equals(LocatorUtils.property(thisLocator, "primeMeridian", lhsPrimeMeridian), LocatorUtils.property(thatLocator, "primeMeridian", rhsPrimeMeridian), lhsPrimeMeridian, rhsPrimeMeridian)) {
483
                 return false;
484
             }
485
         }
486
         {
487
             List<CTOperationPropertyType> lhsOperation;
488
             lhsOperation = (((this.operation!= null)&&(!this.operation.isEmpty()))?this.getOperation():null);
489
             List<CTOperationPropertyType> rhsOperation;
490
             rhsOperation = (((that.operation!= null)&&(!that.operation.isEmpty()))?that.getOperation():null);
491
             if (!strategy.equals(LocatorUtils.property(thisLocator, "operation", lhsOperation), LocatorUtils.property(thatLocator, "operation", rhsOperation), lhsOperation, rhsOperation)) {
492
                 return false;
493
             }
494
         }
495
         {
496
             List<CTOperationMethodPropertyType> lhsOperationMethod;
497
             lhsOperationMethod = (((this.operationMethod!= null)&&(!this.operationMethod.isEmpty()))?this.getOperationMethod():null);
498
             List<CTOperationMethodPropertyType> rhsOperationMethod;
499
             rhsOperationMethod = (((that.operationMethod!= null)&&(!that.operationMethod.isEmpty()))?that.getOperationMethod():null);
500
             if (!strategy.equals(LocatorUtils.property(thisLocator, "operationMethod", lhsOperationMethod), LocatorUtils.property(thatLocator, "operationMethod", rhsOperationMethod), lhsOperationMethod, rhsOperationMethod)) {
501
                 return false;
502
             }
503
         }
504
         {
505
             List<CTOperationParametersPropertyType> lhsParameters;
506
             lhsParameters = (((this.parameters!= null)&&(!this.parameters.isEmpty()))?this.getParameters():null);
507
             List<CTOperationParametersPropertyType> rhsParameters;
508
             rhsParameters = (((that.parameters!= null)&&(!that.parameters.isEmpty()))?that.getParameters():null);
509
             if (!strategy.equals(LocatorUtils.property(thisLocator, "parameters", lhsParameters), LocatorUtils.property(thatLocator, "parameters", rhsParameters), lhsParameters, rhsParameters)) {
510
                 return false;
511
             }
512
         }
513
         return true;
514
     }
515
 
516
     public boolean equals(Object object) {
517
         final EqualsStrategy strategy = JAXBEqualsStrategy.INSTANCE;
518
         return equals(null, null, object, strategy);
519
     }
520
 
521
     public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) {
522
         int currentHashCode = super.hashCode(locator, strategy);
523
         {
524
             List<CTCRSPropertyType> theCrs;
525
             theCrs = (((this.crs!= null)&&(!this.crs.isEmpty()))?this.getCrs():null);
526
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "crs", theCrs), currentHashCode, theCrs);
527
         }
528
         {
529
             List<CTCoordinateSystemPropertyType> theCoordinateSystem;
530
             theCoordinateSystem = (((this.coordinateSystem!= null)&&(!this.coordinateSystem.isEmpty()))?this.getCoordinateSystem():null);
531
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "coordinateSystem", theCoordinateSystem), currentHashCode, theCoordinateSystem);
532
         }
533
         {
534
             List<CTCoordinateSystemAxisPropertyType> theAxis;
535
             theAxis = (((this.axis!= null)&&(!this.axis.isEmpty()))?this.getAxis():null);
536
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "axis", theAxis), currentHashCode, theAxis);
537
         }
538
         {
539
             List<CTDatumPropertyType> theDatum;
540
             theDatum = (((this.datum!= null)&&(!this.datum.isEmpty()))?this.getDatum():null);
541
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "datum", theDatum), currentHashCode, theDatum);
542
         }
543
         {
544
             List<CTEllipsoidPropertyType> theEllipsoid;
545
             theEllipsoid = (((this.ellipsoid!= null)&&(!this.ellipsoid.isEmpty()))?this.getEllipsoid():null);
546
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "ellipsoid", theEllipsoid), currentHashCode, theEllipsoid);
547
         }
548
         {
549
             List<CTPrimeMeridianPropertyType> thePrimeMeridian;
550
             thePrimeMeridian = (((this.primeMeridian!= null)&&(!this.primeMeridian.isEmpty()))?this.getPrimeMeridian():null);
551
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "primeMeridian", thePrimeMeridian), currentHashCode, thePrimeMeridian);
552
         }
553
         {
554
             List<CTOperationPropertyType> theOperation;
555
             theOperation = (((this.operation!= null)&&(!this.operation.isEmpty()))?this.getOperation():null);
556
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "operation", theOperation), currentHashCode, theOperation);
557
         }
558
         {
559
             List<CTOperationMethodPropertyType> theOperationMethod;
560
             theOperationMethod = (((this.operationMethod!= null)&&(!this.operationMethod.isEmpty()))?this.getOperationMethod():null);
561
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "operationMethod", theOperationMethod), currentHashCode, theOperationMethod);
562
         }
563
         {
564
             List<CTOperationParametersPropertyType> theParameters;
565
             theParameters = (((this.parameters!= null)&&(!this.parameters.isEmpty()))?this.getParameters():null);
566
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "parameters", theParameters), currentHashCode, theParameters);
567
         }
568
         return currentHashCode;
569
     }
570
 
571
     public int hashCode() {
572
         final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE;
573
         return this.hashCode(null, strategy);
574
     }
575
 
576
     public Object clone() {
577
         return copyTo(createNewInstance());
578
     }
579
 
580
     public Object copyTo(Object target) {
581
         final CopyStrategy strategy = JAXBCopyStrategy.INSTANCE;
582
         return copyTo(null, target, strategy);
583
     }
584
 
585
     public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
586
         final Object draftCopy = ((target == null)?createNewInstance():target);
587
         super.copyTo(locator, draftCopy, strategy);
588
         if (draftCopy instanceof CTCrsCatalogueType) {
589
             final CTCrsCatalogueType copy = ((CTCrsCatalogueType) draftCopy);
590
             if ((this.crs!= null)&&(!this.crs.isEmpty())) {
591
                 List<CTCRSPropertyType> sourceCrs;
592
                 sourceCrs = (((this.crs!= null)&&(!this.crs.isEmpty()))?this.getCrs():null);
593
                 @SuppressWarnings("unchecked")
594
                 List<CTCRSPropertyType> copyCrs = ((List<CTCRSPropertyType> ) strategy.copy(LocatorUtils.property(locator, "crs", sourceCrs), sourceCrs));
595
                 copy.crs = null;
596
                 if (copyCrs!= null) {
597
                     List<CTCRSPropertyType> uniqueCrsl = copy.getCrs();
598
                     uniqueCrsl.addAll(copyCrs);
599
                 }
600
             } else {
601
                 copy.crs = null;
602
             }
603
             if ((this.coordinateSystem!= null)&&(!this.coordinateSystem.isEmpty())) {
604
                 List<CTCoordinateSystemPropertyType> sourceCoordinateSystem;
605
                 sourceCoordinateSystem = (((this.coordinateSystem!= null)&&(!this.coordinateSystem.isEmpty()))?this.getCoordinateSystem():null);
606
                 @SuppressWarnings("unchecked")
607
                 List<CTCoordinateSystemPropertyType> copyCoordinateSystem = ((List<CTCoordinateSystemPropertyType> ) strategy.copy(LocatorUtils.property(locator, "coordinateSystem", sourceCoordinateSystem), sourceCoordinateSystem));
608
                 copy.coordinateSystem = null;
609
                 if (copyCoordinateSystem!= null) {
610
                     List<CTCoordinateSystemPropertyType> uniqueCoordinateSysteml = copy.getCoordinateSystem();
611
                     uniqueCoordinateSysteml.addAll(copyCoordinateSystem);
612
                 }
613
             } else {
614
                 copy.coordinateSystem = null;
615
             }
616
             if ((this.axis!= null)&&(!this.axis.isEmpty())) {
617
                 List<CTCoordinateSystemAxisPropertyType> sourceAxis;
618
                 sourceAxis = (((this.axis!= null)&&(!this.axis.isEmpty()))?this.getAxis():null);
619
                 @SuppressWarnings("unchecked")
620
                 List<CTCoordinateSystemAxisPropertyType> copyAxis = ((List<CTCoordinateSystemAxisPropertyType> ) strategy.copy(LocatorUtils.property(locator, "axis", sourceAxis), sourceAxis));
621
                 copy.axis = null;
622
                 if (copyAxis!= null) {
623
                     List<CTCoordinateSystemAxisPropertyType> uniqueAxisl = copy.getAxis();
624
                     uniqueAxisl.addAll(copyAxis);
625
                 }
626
             } else {
627
                 copy.axis = null;
628
             }
629
             if ((this.datum!= null)&&(!this.datum.isEmpty())) {
630
                 List<CTDatumPropertyType> sourceDatum;
631
                 sourceDatum = (((this.datum!= null)&&(!this.datum.isEmpty()))?this.getDatum():null);
632
                 @SuppressWarnings("unchecked")
633
                 List<CTDatumPropertyType> copyDatum = ((List<CTDatumPropertyType> ) strategy.copy(LocatorUtils.property(locator, "datum", sourceDatum), sourceDatum));
634
                 copy.datum = null;
635
                 if (copyDatum!= null) {
636
                     List<CTDatumPropertyType> uniqueDatuml = copy.getDatum();
637
                     uniqueDatuml.addAll(copyDatum);
638
                 }
639
             } else {
640
                 copy.datum = null;
641
             }
642
             if ((this.ellipsoid!= null)&&(!this.ellipsoid.isEmpty())) {
643
                 List<CTEllipsoidPropertyType> sourceEllipsoid;
644
                 sourceEllipsoid = (((this.ellipsoid!= null)&&(!this.ellipsoid.isEmpty()))?this.getEllipsoid():null);
645
                 @SuppressWarnings("unchecked")
646
                 List<CTEllipsoidPropertyType> copyEllipsoid = ((List<CTEllipsoidPropertyType> ) strategy.copy(LocatorUtils.property(locator, "ellipsoid", sourceEllipsoid), sourceEllipsoid));
647
                 copy.ellipsoid = null;
648
                 if (copyEllipsoid!= null) {
649
                     List<CTEllipsoidPropertyType> uniqueEllipsoidl = copy.getEllipsoid();
650
                     uniqueEllipsoidl.addAll(copyEllipsoid);
651
                 }
652
             } else {
653
                 copy.ellipsoid = null;
654
             }
655
             if ((this.primeMeridian!= null)&&(!this.primeMeridian.isEmpty())) {
656
                 List<CTPrimeMeridianPropertyType> sourcePrimeMeridian;
657
                 sourcePrimeMeridian = (((this.primeMeridian!= null)&&(!this.primeMeridian.isEmpty()))?this.getPrimeMeridian():null);
658
                 @SuppressWarnings("unchecked")
659
                 List<CTPrimeMeridianPropertyType> copyPrimeMeridian = ((List<CTPrimeMeridianPropertyType> ) strategy.copy(LocatorUtils.property(locator, "primeMeridian", sourcePrimeMeridian), sourcePrimeMeridian));
660
                 copy.primeMeridian = null;
661
                 if (copyPrimeMeridian!= null) {
662
                     List<CTPrimeMeridianPropertyType> uniquePrimeMeridianl = copy.getPrimeMeridian();
663
                     uniquePrimeMeridianl.addAll(copyPrimeMeridian);
664
                 }
665
             } else {
666
                 copy.primeMeridian = null;
667
             }
668
             if ((this.operation!= null)&&(!this.operation.isEmpty())) {
669
                 List<CTOperationPropertyType> sourceOperation;
670
                 sourceOperation = (((this.operation!= null)&&(!this.operation.isEmpty()))?this.getOperation():null);
671
                 @SuppressWarnings("unchecked")
672
                 List<CTOperationPropertyType> copyOperation = ((List<CTOperationPropertyType> ) strategy.copy(LocatorUtils.property(locator, "operation", sourceOperation), sourceOperation));
673
                 copy.operation = null;
674
                 if (copyOperation!= null) {
675
                     List<CTOperationPropertyType> uniqueOperationl = copy.getOperation();
676
                     uniqueOperationl.addAll(copyOperation);
677
                 }
678
             } else {
679
                 copy.operation = null;
680
             }
681
             if ((this.operationMethod!= null)&&(!this.operationMethod.isEmpty())) {
682
                 List<CTOperationMethodPropertyType> sourceOperationMethod;
683
                 sourceOperationMethod = (((this.operationMethod!= null)&&(!this.operationMethod.isEmpty()))?this.getOperationMethod():null);
684
                 @SuppressWarnings("unchecked")
685
                 List<CTOperationMethodPropertyType> copyOperationMethod = ((List<CTOperationMethodPropertyType> ) strategy.copy(LocatorUtils.property(locator, "operationMethod", sourceOperationMethod), sourceOperationMethod));
686
                 copy.operationMethod = null;
687
                 if (copyOperationMethod!= null) {
688
                     List<CTOperationMethodPropertyType> uniqueOperationMethodl = copy.getOperationMethod();
689
                     uniqueOperationMethodl.addAll(copyOperationMethod);
690
                 }
691
             } else {
692
                 copy.operationMethod = null;
693
             }
694
             if ((this.parameters!= null)&&(!this.parameters.isEmpty())) {
695
                 List<CTOperationParametersPropertyType> sourceParameters;
696
                 sourceParameters = (((this.parameters!= null)&&(!this.parameters.isEmpty()))?this.getParameters():null);
697
                 @SuppressWarnings("unchecked")
698
                 List<CTOperationParametersPropertyType> copyParameters = ((List<CTOperationParametersPropertyType> ) strategy.copy(LocatorUtils.property(locator, "parameters", sourceParameters), sourceParameters));
699
                 copy.parameters = null;
700
                 if (copyParameters!= null) {
701
                     List<CTOperationParametersPropertyType> uniqueParametersl = copy.getParameters();
702
                     uniqueParametersl.addAll(copyParameters);
703
                 }
704
             } else {
705
                 copy.parameters = null;
706
             }
707
         }
708
         return draftCopy;
709
     }
710
 
711
     public Object createNewInstance() {
712
         return new CTCrsCatalogueType();
713
     }
714
 
715
     public void mergeFrom(Object left, Object right) {
716
         final MergeStrategy strategy = JAXBMergeStrategy.INSTANCE;
717
         mergeFrom(null, null, left, right, strategy);
718
     }
719
 
720
     public void mergeFrom(ObjectLocator leftLocator, ObjectLocator rightLocator, Object left, Object right, MergeStrategy strategy) {
721
         super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
722
         if (right instanceof CTCrsCatalogueType) {
723
             final CTCrsCatalogueType target = this;
724
             final CTCrsCatalogueType leftObject = ((CTCrsCatalogueType) left);
725
             final CTCrsCatalogueType rightObject = ((CTCrsCatalogueType) right);
726
             {
727
                 List<CTCRSPropertyType> lhsCrs;
728
                 lhsCrs = (((leftObject.crs!= null)&&(!leftObject.crs.isEmpty()))?leftObject.getCrs():null);
729
                 List<CTCRSPropertyType> rhsCrs;
730
                 rhsCrs = (((rightObject.crs!= null)&&(!rightObject.crs.isEmpty()))?rightObject.getCrs():null);
731
                 List<CTCRSPropertyType> mergedCrs = ((List<CTCRSPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator, "crs", lhsCrs), LocatorUtils.property(rightLocator, "crs", rhsCrs), lhsCrs, rhsCrs));
732
                 target.crs = null;
733
                 if (mergedCrs!= null) {
734
                     List<CTCRSPropertyType> uniqueCrsl = target.getCrs();
735
                     uniqueCrsl.addAll(mergedCrs);
736
                 }
737
             }
738
             {
739
                 List<CTCoordinateSystemPropertyType> lhsCoordinateSystem;
740
                 lhsCoordinateSystem = (((leftObject.coordinateSystem!= null)&&(!leftObject.coordinateSystem.isEmpty()))?leftObject.getCoordinateSystem():null);
741
                 List<CTCoordinateSystemPropertyType> rhsCoordinateSystem;
742
                 rhsCoordinateSystem = (((rightObject.coordinateSystem!= null)&&(!rightObject.coordinateSystem.isEmpty()))?rightObject.getCoordinateSystem():null);
743
                 List<CTCoordinateSystemPropertyType> mergedCoordinateSystem = ((List<CTCoordinateSystemPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator, "coordinateSystem", lhsCoordinateSystem), LocatorUtils.property(rightLocator, "coordinateSystem", rhsCoordinateSystem), lhsCoordinateSystem, rhsCoordinateSystem));
744
                 target.coordinateSystem = null;
745
                 if (mergedCoordinateSystem!= null) {
746
                     List<CTCoordinateSystemPropertyType> uniqueCoordinateSysteml = target.getCoordinateSystem();
747
                     uniqueCoordinateSysteml.addAll(mergedCoordinateSystem);
748
                 }
749
             }
750
             {
751
                 List<CTCoordinateSystemAxisPropertyType> lhsAxis;
752
                 lhsAxis = (((leftObject.axis!= null)&&(!leftObject.axis.isEmpty()))?leftObject.getAxis():null);
753
                 List<CTCoordinateSystemAxisPropertyType> rhsAxis;
754
                 rhsAxis = (((rightObject.axis!= null)&&(!rightObject.axis.isEmpty()))?rightObject.getAxis():null);
755
                 List<CTCoordinateSystemAxisPropertyType> mergedAxis = ((List<CTCoordinateSystemAxisPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator, "axis", lhsAxis), LocatorUtils.property(rightLocator, "axis", rhsAxis), lhsAxis, rhsAxis));
756
                 target.axis = null;
757
                 if (mergedAxis!= null) {
758
                     List<CTCoordinateSystemAxisPropertyType> uniqueAxisl = target.getAxis();
759
                     uniqueAxisl.addAll(mergedAxis);
760
                 }
761
             }
762
             {
763
                 List<CTDatumPropertyType> lhsDatum;
764
                 lhsDatum = (((leftObject.datum!= null)&&(!leftObject.datum.isEmpty()))?leftObject.getDatum():null);
765
                 List<CTDatumPropertyType> rhsDatum;
766
                 rhsDatum = (((rightObject.datum!= null)&&(!rightObject.datum.isEmpty()))?rightObject.getDatum():null);
767
                 List<CTDatumPropertyType> mergedDatum = ((List<CTDatumPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator, "datum", lhsDatum), LocatorUtils.property(rightLocator, "datum", rhsDatum), lhsDatum, rhsDatum));
768
                 target.datum = null;
769
                 if (mergedDatum!= null) {
770
                     List<CTDatumPropertyType> uniqueDatuml = target.getDatum();
771
                     uniqueDatuml.addAll(mergedDatum);
772
                 }
773
             }
774
             {
775
                 List<CTEllipsoidPropertyType> lhsEllipsoid;
776
                 lhsEllipsoid = (((leftObject.ellipsoid!= null)&&(!leftObject.ellipsoid.isEmpty()))?leftObject.getEllipsoid():null);
777
                 List<CTEllipsoidPropertyType> rhsEllipsoid;
778
                 rhsEllipsoid = (((rightObject.ellipsoid!= null)&&(!rightObject.ellipsoid.isEmpty()))?rightObject.getEllipsoid():null);
779
                 List<CTEllipsoidPropertyType> mergedEllipsoid = ((List<CTEllipsoidPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator, "ellipsoid", lhsEllipsoid), LocatorUtils.property(rightLocator, "ellipsoid", rhsEllipsoid), lhsEllipsoid, rhsEllipsoid));
780
                 target.ellipsoid = null;
781
                 if (mergedEllipsoid!= null) {
782
                     List<CTEllipsoidPropertyType> uniqueEllipsoidl = target.getEllipsoid();
783
                     uniqueEllipsoidl.addAll(mergedEllipsoid);
784
                 }
785
             }
786
             {
787
                 List<CTPrimeMeridianPropertyType> lhsPrimeMeridian;
788
                 lhsPrimeMeridian = (((leftObject.primeMeridian!= null)&&(!leftObject.primeMeridian.isEmpty()))?leftObject.getPrimeMeridian():null);
789
                 List<CTPrimeMeridianPropertyType> rhsPrimeMeridian;
790
                 rhsPrimeMeridian = (((rightObject.primeMeridian!= null)&&(!rightObject.primeMeridian.isEmpty()))?rightObject.getPrimeMeridian():null);
791
                 List<CTPrimeMeridianPropertyType> mergedPrimeMeridian = ((List<CTPrimeMeridianPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator, "primeMeridian", lhsPrimeMeridian), LocatorUtils.property(rightLocator, "primeMeridian", rhsPrimeMeridian), lhsPrimeMeridian, rhsPrimeMeridian));
792
                 target.primeMeridian = null;
793
                 if (mergedPrimeMeridian!= null) {
794
                     List<CTPrimeMeridianPropertyType> uniquePrimeMeridianl = target.getPrimeMeridian();
795
                     uniquePrimeMeridianl.addAll(mergedPrimeMeridian);
796
                 }
797
             }
798
             {
799
                 List<CTOperationPropertyType> lhsOperation;
800
                 lhsOperation = (((leftObject.operation!= null)&&(!leftObject.operation.isEmpty()))?leftObject.getOperation():null);
801
                 List<CTOperationPropertyType> rhsOperation;
802
                 rhsOperation = (((rightObject.operation!= null)&&(!rightObject.operation.isEmpty()))?rightObject.getOperation():null);
803
                 List<CTOperationPropertyType> mergedOperation = ((List<CTOperationPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator, "operation", lhsOperation), LocatorUtils.property(rightLocator, "operation", rhsOperation), lhsOperation, rhsOperation));
804
                 target.operation = null;
805
                 if (mergedOperation!= null) {
806
                     List<CTOperationPropertyType> uniqueOperationl = target.getOperation();
807
                     uniqueOperationl.addAll(mergedOperation);
808
                 }
809
             }
810
             {
811
                 List<CTOperationMethodPropertyType> lhsOperationMethod;
812
                 lhsOperationMethod = (((leftObject.operationMethod!= null)&&(!leftObject.operationMethod.isEmpty()))?leftObject.getOperationMethod():null);
813
                 List<CTOperationMethodPropertyType> rhsOperationMethod;
814
                 rhsOperationMethod = (((rightObject.operationMethod!= null)&&(!rightObject.operationMethod.isEmpty()))?rightObject.getOperationMethod():null);
815
                 List<CTOperationMethodPropertyType> mergedOperationMethod = ((List<CTOperationMethodPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator, "operationMethod", lhsOperationMethod), LocatorUtils.property(rightLocator, "operationMethod", rhsOperationMethod), lhsOperationMethod, rhsOperationMethod));
816
                 target.operationMethod = null;
817
                 if (mergedOperationMethod!= null) {
818
                     List<CTOperationMethodPropertyType> uniqueOperationMethodl = target.getOperationMethod();
819
                     uniqueOperationMethodl.addAll(mergedOperationMethod);
820
                 }
821
             }
822
             {
823
                 List<CTOperationParametersPropertyType> lhsParameters;
824
                 lhsParameters = (((leftObject.parameters!= null)&&(!leftObject.parameters.isEmpty()))?leftObject.getParameters():null);
825
                 List<CTOperationParametersPropertyType> rhsParameters;
826
                 rhsParameters = (((rightObject.parameters!= null)&&(!rightObject.parameters.isEmpty()))?rightObject.getParameters():null);
827
                 List<CTOperationParametersPropertyType> mergedParameters = ((List<CTOperationParametersPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator, "parameters", lhsParameters), LocatorUtils.property(rightLocator, "parameters", rhsParameters), lhsParameters, rhsParameters));
828
                 target.parameters = null;
829
                 if (mergedParameters!= null) {
830
                     List<CTOperationParametersPropertyType> uniqueParametersl = target.getParameters();
831
                     uniqueParametersl.addAll(mergedParameters);
832
                 }
833
             }
834
         }
835
     }
836
 
837
     public void setCrs(List<CTCRSPropertyType> value) {
838
         this.crs = null;
839
         List<CTCRSPropertyType> draftl = this.getCrs();
840
         draftl.addAll(value);
841
     }
842
 
843
     public void setCoordinateSystem(List<CTCoordinateSystemPropertyType> value) {
844
         this.coordinateSystem = null;
845
         List<CTCoordinateSystemPropertyType> draftl = this.getCoordinateSystem();
846
         draftl.addAll(value);
847
     }
848
 
849
     public void setAxis(List<CTCoordinateSystemAxisPropertyType> value) {
850
         this.axis = null;
851
         List<CTCoordinateSystemAxisPropertyType> draftl = this.getAxis();
852
         draftl.addAll(value);
853
     }
854
 
855
     public void setDatum(List<CTDatumPropertyType> value) {
856
         this.datum = null;
857
         List<CTDatumPropertyType> draftl = this.getDatum();
858
         draftl.addAll(value);
859
     }
860
 
861
     public void setEllipsoid(List<CTEllipsoidPropertyType> value) {
862
         this.ellipsoid = null;
863
         List<CTEllipsoidPropertyType> draftl = this.getEllipsoid();
864
         draftl.addAll(value);
865
     }
866
 
867
     public void setPrimeMeridian(List<CTPrimeMeridianPropertyType> value) {
868
         this.primeMeridian = null;
869
         List<CTPrimeMeridianPropertyType> draftl = this.getPrimeMeridian();
870
         draftl.addAll(value);
871
     }
872
 
873
     public void setOperation(List<CTOperationPropertyType> value) {
874
         this.operation = null;
875
         List<CTOperationPropertyType> draftl = this.getOperation();
876
         draftl.addAll(value);
877
     }
878
 
879
     public void setOperationMethod(List<CTOperationMethodPropertyType> value) {
880
         this.operationMethod = null;
881
         List<CTOperationMethodPropertyType> draftl = this.getOperationMethod();
882
         draftl.addAll(value);
883
     }
884
 
885
     public void setParameters(List<CTOperationParametersPropertyType> value) {
886
         this.parameters = null;
887
         List<CTOperationParametersPropertyType> draftl = this.getParameters();
888
         draftl.addAll(value);
889
     }
890
 
891
     public CTCrsCatalogueType withCrs(CTCRSPropertyType... values) {
892
         if (values!= null) {
893
             for (CTCRSPropertyType value: values) {
894
                 getCrs().add(value);
895
             }
896
         }
897
         return this;
898
     }
899
 
900
     public CTCrsCatalogueType withCrs(Collection<CTCRSPropertyType> values) {
901
         if (values!= null) {
902
             getCrs().addAll(values);
903
         }
904
         return this;
905
     }
906
 
907
     public CTCrsCatalogueType withCoordinateSystem(CTCoordinateSystemPropertyType... values) {
908
         if (values!= null) {
909
             for (CTCoordinateSystemPropertyType value: values) {
910
                 getCoordinateSystem().add(value);
911
             }
912
         }
913
         return this;
914
     }
915
 
916
     public CTCrsCatalogueType withCoordinateSystem(Collection<CTCoordinateSystemPropertyType> values) {
917
         if (values!= null) {
918
             getCoordinateSystem().addAll(values);
919
         }
920
         return this;
921
     }
922
 
923
     public CTCrsCatalogueType withAxis(CTCoordinateSystemAxisPropertyType... values) {
924
         if (values!= null) {
925
             for (CTCoordinateSystemAxisPropertyType value: values) {
926
                 getAxis().add(value);
927
             }
928
         }
929
         return this;
930
     }
931
 
932
     public CTCrsCatalogueType withAxis(Collection<CTCoordinateSystemAxisPropertyType> values) {
933
         if (values!= null) {
934
             getAxis().addAll(values);
935
         }
936
         return this;
937
     }
938
 
939
     public CTCrsCatalogueType withDatum(CTDatumPropertyType... values) {
940
         if (values!= null) {
941
             for (CTDatumPropertyType value: values) {
942
                 getDatum().add(value);
943
             }
944
         }
945
         return this;
946
     }
947
 
948
     public CTCrsCatalogueType withDatum(Collection<CTDatumPropertyType> values) {
949
         if (values!= null) {
950
             getDatum().addAll(values);
951
         }
952
         return this;
953
     }
954
 
955
     public CTCrsCatalogueType withEllipsoid(CTEllipsoidPropertyType... values) {
956
         if (values!= null) {
957
             for (CTEllipsoidPropertyType value: values) {
958
                 getEllipsoid().add(value);
959
             }
960
         }
961
         return this;
962
     }
963
 
964
     public CTCrsCatalogueType withEllipsoid(Collection<CTEllipsoidPropertyType> values) {
965
         if (values!= null) {
966
             getEllipsoid().addAll(values);
967
         }
968
         return this;
969
     }
970
 
971
     public CTCrsCatalogueType withPrimeMeridian(CTPrimeMeridianPropertyType... values) {
972
         if (values!= null) {
973
             for (CTPrimeMeridianPropertyType value: values) {
974
                 getPrimeMeridian().add(value);
975
             }
976
         }
977
         return this;
978
     }
979
 
980
     public CTCrsCatalogueType withPrimeMeridian(Collection<CTPrimeMeridianPropertyType> values) {
981
         if (values!= null) {
982
             getPrimeMeridian().addAll(values);
983
         }
984
         return this;
985
     }
986
 
987
     public CTCrsCatalogueType withOperation(CTOperationPropertyType... values) {
988
         if (values!= null) {
989
             for (CTOperationPropertyType value: values) {
990
                 getOperation().add(value);
991
             }
992
         }
993
         return this;
994
     }
995
 
996
     public CTCrsCatalogueType withOperation(Collection<CTOperationPropertyType> values) {
997
         if (values!= null) {
998
             getOperation().addAll(values);
999
         }
1000
        return this;
1001
    }
1002
1003
    public CTCrsCatalogueType withOperationMethod(CTOperationMethodPropertyType... values) {
1004
        if (values!= null) {
1005
            for (CTOperationMethodPropertyType value: values) {
1006
                getOperationMethod().add(value);
1007
            }
1008
        }
1009
        return this;
1010
    }
1011
1012
    public CTCrsCatalogueType withOperationMethod(Collection<CTOperationMethodPropertyType> values) {
1013
        if (values!= null) {
1014
            getOperationMethod().addAll(values);
1015
        }
1016
        return this;
1017
    }
1018
1019
    public CTCrsCatalogueType withParameters(CTOperationParametersPropertyType... values) {
1020
        if (values!= null) {
1021
            for (CTOperationParametersPropertyType value: values) {
1022
                getParameters().add(value);
1023
            }
1024
        }
1025
        return this;
1026
    }
1027
1028
    public CTCrsCatalogueType withParameters(Collection<CTOperationParametersPropertyType> values) {
1029
        if (values!= null) {
1030
            getParameters().addAll(values);
1031
        }
1032
        return this;
1033
    }
1034
1035
    public CTCrsCatalogueType withCrs(List<CTCRSPropertyType> value) {
1036
        setCrs(value);
1037
        return this;
1038
    }
1039
1040
    public CTCrsCatalogueType withCoordinateSystem(List<CTCoordinateSystemPropertyType> value) {
1041
        setCoordinateSystem(value);
1042
        return this;
1043
    }
1044
1045
    public CTCrsCatalogueType withAxis(List<CTCoordinateSystemAxisPropertyType> value) {
1046
        setAxis(value);
1047
        return this;
1048
    }
1049
1050
    public CTCrsCatalogueType withDatum(List<CTDatumPropertyType> value) {
1051
        setDatum(value);
1052
        return this;
1053
    }
1054
1055
    public CTCrsCatalogueType withEllipsoid(List<CTEllipsoidPropertyType> value) {
1056
        setEllipsoid(value);
1057
        return this;
1058
    }
1059
1060
    public CTCrsCatalogueType withPrimeMeridian(List<CTPrimeMeridianPropertyType> value) {
1061
        setPrimeMeridian(value);
1062
        return this;
1063
    }
1064
1065
    public CTCrsCatalogueType withOperation(List<CTOperationPropertyType> value) {
1066
        setOperation(value);
1067
        return this;
1068
    }
1069
1070
    public CTCrsCatalogueType withOperationMethod(List<CTOperationMethodPropertyType> value) {
1071
        setOperationMethod(value);
1072
        return this;
1073
    }
1074
1075
    public CTCrsCatalogueType withParameters(List<CTOperationParametersPropertyType> value) {
1076
        setParameters(value);
1077
        return this;
1078
    }
1079
1080
    @Override
1081
    public CTCrsCatalogueType withName(CharacterStringPropertyType value) {
1082
        setName(value);
1083
        return this;
1084
    }
1085
1086
    @Override
1087
    public CTCrsCatalogueType withScope(CharacterStringPropertyType... values) {
1088
        if (values!= null) {
1089
            for (CharacterStringPropertyType value: values) {
1090
                getScope().add(value);