Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   //
   // This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.11 
   // See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
   // Any modifications to this file will be lost upon recompilation of the source schema. 
   // Generated on: 2015.03.28 at 10:20:34 AM CET 
   //
   
   
   package net.opengis.iso19139.gmx.v_20060504;
  
  import java.util.List;

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>
 
  
  @XmlType(name = "CT_CrsCatalogue_Type", propOrder = {
      "crs",
      "coordinateSystem",
      "axis",
      "datum",
      "ellipsoid",
      "primeMeridian",
      "operation",
      "operationMethod",
      "parameters"
  })
  public class CTCrsCatalogueType
      extends AbstractCTCatalogueType
      implements CloneableCopyToEqualsHashCodeMergeFromToString
  {
  
      @XmlElement(required = true)
      protected List<CTCRSPropertyTypecrs;
      protected List<CTDatumPropertyTypedatum;
      protected List<CTEllipsoidPropertyTypeellipsoid;
      protected List<CTOperationPropertyTypeoperation;
      protected List<CTOperationParametersPropertyTypeparameters;

    
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

 
     public List<CTCRSPropertyTypegetCrs() {
         if ( == null) {
              = new ArrayList<CTCRSPropertyType>();
         }
         return this.;
     }

    
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

 
         if ( == null) {
              = new ArrayList<CTCoordinateSystemPropertyType>();
         }
         return this.;
     }

    
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

 
         if ( == null) {
              = new ArrayList<CTCoordinateSystemAxisPropertyType>();
         }
         return this.;
     }

    
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

 
     public List<CTDatumPropertyTypegetDatum() {
         if ( == null) {
              = new ArrayList<CTDatumPropertyType>();
         }
         return this.;
     }

    
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

 
         if ( == null) {
              = new ArrayList<CTEllipsoidPropertyType>();
         }
         return this.;
     }

    
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

 
         if ( == null) {
              = new ArrayList<CTPrimeMeridianPropertyType>();
         }
         return this.;
     }

    
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

 
         if ( == null) {
              = new ArrayList<CTOperationPropertyType>();
         }
         return this.;
     }

    
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

 
         if ( == null) {
              = new ArrayList<CTOperationMethodPropertyType>();
         }
         return this.;
     }

    
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

 
         if ( == null) {
              = new ArrayList<CTOperationParametersPropertyType>();
         }
         return this.;
     }
 
     public String toString() {
         final ToStringStrategy strategy = .;
         final StringBuilder buffer = new StringBuilder();
         append(nullbufferstrategy);
         return buffer.toString();
     }
 
     public StringBuilder append(ObjectLocator locatorStringBuilder bufferToStringStrategy strategy) {
         strategy.appendStart(locatorthisbuffer);
         appendFields(locatorbufferstrategy);
         strategy.appendEnd(locatorthisbuffer);
         return buffer;
     }
 
     public StringBuilder appendFields(ObjectLocator locatorStringBuilder bufferToStringStrategy strategy) {
         super.appendFields(locatorbufferstrategy);
         {
             List<CTCRSPropertyTypetheCrs;
             theCrs = (((this.!= null)&&(!this..isEmpty()))?this.getCrs():null);
             strategy.appendField(locatorthis"crs"buffertheCrs);
         }
         {
             List<CTCoordinateSystemPropertyTypetheCoordinateSystem;
             theCoordinateSystem = (((this.!= null)&&(!this..isEmpty()))?this.getCoordinateSystem():null);
             strategy.appendField(locatorthis"coordinateSystem"buffertheCoordinateSystem);
         }
         {
             List<CTCoordinateSystemAxisPropertyTypetheAxis;
             theAxis = (((this.!= null)&&(!this..isEmpty()))?this.getAxis():null);
             strategy.appendField(locatorthis"axis"buffertheAxis);
         }
         {
             List<CTDatumPropertyTypetheDatum;
             theDatum = (((this.!= null)&&(!this..isEmpty()))?this.getDatum():null);
             strategy.appendField(locatorthis"datum"buffertheDatum);
         }
         {
             List<CTEllipsoidPropertyTypetheEllipsoid;
             theEllipsoid = (((this.!= null)&&(!this..isEmpty()))?this.getEllipsoid():null);
             strategy.appendField(locatorthis"ellipsoid"buffertheEllipsoid);
         }
         {
             List<CTPrimeMeridianPropertyTypethePrimeMeridian;
             thePrimeMeridian = (((this.!= null)&&(!this..isEmpty()))?this.getPrimeMeridian():null);
             strategy.appendField(locatorthis"primeMeridian"bufferthePrimeMeridian);
         }
         {
             List<CTOperationPropertyTypetheOperation;
             theOperation = (((this.!= null)&&(!this..isEmpty()))?this.getOperation():null);
             strategy.appendField(locatorthis"operation"buffertheOperation);
         }
         {
             List<CTOperationMethodPropertyTypetheOperationMethod;
             theOperationMethod = (((this.!= null)&&(!this..isEmpty()))?this.getOperationMethod():null);
             strategy.appendField(locatorthis"operationMethod"buffertheOperationMethod);
         }
         {
             List<CTOperationParametersPropertyTypetheParameters;
             theParameters = (((this.!= null)&&(!this..isEmpty()))?this.getParameters():null);
             strategy.appendField(locatorthis"parameters"buffertheParameters);
         }
         return buffer;
     }
 
     public boolean equals(ObjectLocator thisLocatorObjectLocator thatLocatorObject objectEqualsStrategy strategy) {
         if (!(object instanceof CTCrsCatalogueType)) {
             return false;
         }
         if (this == object) {
             return true;
         }
         if (!super.equals(thisLocatorthatLocatorobjectstrategy)) {
             return false;
         }
         final CTCrsCatalogueType that = ((CTCrsCatalogueTypeobject);
         {
             List<CTCRSPropertyTypelhsCrs;
             lhsCrs = (((this.!= null)&&(!this..isEmpty()))?this.getCrs():null);
             List<CTCRSPropertyTyperhsCrs;
             rhsCrs = (((that.crs!= null)&&(!that.crs.isEmpty()))?that.getCrs():null);
             if (!strategy.equals(LocatorUtils.property(thisLocator"crs"lhsCrs), LocatorUtils.property(thatLocator"crs"rhsCrs), lhsCrsrhsCrs)) {
                 return false;
             }
         }
         {
             List<CTCoordinateSystemPropertyTypelhsCoordinateSystem;
             lhsCoordinateSystem = (((this.!= null)&&(!this..isEmpty()))?this.getCoordinateSystem():null);
             List<CTCoordinateSystemPropertyTyperhsCoordinateSystem;
             rhsCoordinateSystem = (((that.coordinateSystem!= null)&&(!that.coordinateSystem.isEmpty()))?that.getCoordinateSystem():null);
             if (!strategy.equals(LocatorUtils.property(thisLocator"coordinateSystem"lhsCoordinateSystem), LocatorUtils.property(thatLocator"coordinateSystem"rhsCoordinateSystem), lhsCoordinateSystemrhsCoordinateSystem)) {
                 return false;
             }
         }
         {
             List<CTCoordinateSystemAxisPropertyTypelhsAxis;
             lhsAxis = (((this.!= null)&&(!this..isEmpty()))?this.getAxis():null);
             List<CTCoordinateSystemAxisPropertyTyperhsAxis;
             rhsAxis = (((that.axis!= null)&&(!that.axis.isEmpty()))?that.getAxis():null);
             if (!strategy.equals(LocatorUtils.property(thisLocator"axis"lhsAxis), LocatorUtils.property(thatLocator"axis"rhsAxis), lhsAxisrhsAxis)) {
                 return false;
             }
         }
         {
             List<CTDatumPropertyTypelhsDatum;
             lhsDatum = (((this.!= null)&&(!this..isEmpty()))?this.getDatum():null);
             List<CTDatumPropertyTyperhsDatum;
             rhsDatum = (((that.datum!= null)&&(!that.datum.isEmpty()))?that.getDatum():null);
             if (!strategy.equals(LocatorUtils.property(thisLocator"datum"lhsDatum), LocatorUtils.property(thatLocator"datum"rhsDatum), lhsDatumrhsDatum)) {
                 return false;
             }
         }
         {
             List<CTEllipsoidPropertyTypelhsEllipsoid;
             lhsEllipsoid = (((this.!= null)&&(!this..isEmpty()))?this.getEllipsoid():null);
             List<CTEllipsoidPropertyTyperhsEllipsoid;
             rhsEllipsoid = (((that.ellipsoid!= null)&&(!that.ellipsoid.isEmpty()))?that.getEllipsoid():null);
             if (!strategy.equals(LocatorUtils.property(thisLocator"ellipsoid"lhsEllipsoid), LocatorUtils.property(thatLocator"ellipsoid"rhsEllipsoid), lhsEllipsoidrhsEllipsoid)) {
                 return false;
             }
         }
         {
             List<CTPrimeMeridianPropertyTypelhsPrimeMeridian;
             lhsPrimeMeridian = (((this.!= null)&&(!this..isEmpty()))?this.getPrimeMeridian():null);
             List<CTPrimeMeridianPropertyTyperhsPrimeMeridian;
             rhsPrimeMeridian = (((that.primeMeridian!= null)&&(!that.primeMeridian.isEmpty()))?that.getPrimeMeridian():null);
             if (!strategy.equals(LocatorUtils.property(thisLocator"primeMeridian"lhsPrimeMeridian), LocatorUtils.property(thatLocator"primeMeridian"rhsPrimeMeridian), lhsPrimeMeridianrhsPrimeMeridian)) {
                 return false;
             }
         }
         {
             List<CTOperationPropertyTypelhsOperation;
             lhsOperation = (((this.!= null)&&(!this..isEmpty()))?this.getOperation():null);
             List<CTOperationPropertyTyperhsOperation;
             rhsOperation = (((that.operation!= null)&&(!that.operation.isEmpty()))?that.getOperation():null);
             if (!strategy.equals(LocatorUtils.property(thisLocator"operation"lhsOperation), LocatorUtils.property(thatLocator"operation"rhsOperation), lhsOperationrhsOperation)) {
                 return false;
             }
         }
         {
             List<CTOperationMethodPropertyTypelhsOperationMethod;
             lhsOperationMethod = (((this.!= null)&&(!this..isEmpty()))?this.getOperationMethod():null);
             List<CTOperationMethodPropertyTyperhsOperationMethod;
             rhsOperationMethod = (((that.operationMethod!= null)&&(!that.operationMethod.isEmpty()))?that.getOperationMethod():null);
             if (!strategy.equals(LocatorUtils.property(thisLocator"operationMethod"lhsOperationMethod), LocatorUtils.property(thatLocator"operationMethod"rhsOperationMethod), lhsOperationMethodrhsOperationMethod)) {
                 return false;
             }
         }
         {
             List<CTOperationParametersPropertyTypelhsParameters;
             lhsParameters = (((this.!= null)&&(!this..isEmpty()))?this.getParameters():null);
             List<CTOperationParametersPropertyTyperhsParameters;
             rhsParameters = (((that.parameters!= null)&&(!that.parameters.isEmpty()))?that.getParameters():null);
             if (!strategy.equals(LocatorUtils.property(thisLocator"parameters"lhsParameters), LocatorUtils.property(thatLocator"parameters"rhsParameters), lhsParametersrhsParameters)) {
                 return false;
             }
         }
         return true;
     }
 
     public boolean equals(Object object) {
         final EqualsStrategy strategy = .;
         return equals(nullnullobjectstrategy);
     }
 
     public int hashCode(ObjectLocator locatorHashCodeStrategy strategy) {
         int currentHashCode = super.hashCode(locatorstrategy);
         {
             List<CTCRSPropertyTypetheCrs;
             theCrs = (((this.!= null)&&(!this..isEmpty()))?this.getCrs():null);
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator"crs"theCrs), currentHashCodetheCrs);
         }
         {
             List<CTCoordinateSystemPropertyTypetheCoordinateSystem;
             theCoordinateSystem = (((this.!= null)&&(!this..isEmpty()))?this.getCoordinateSystem():null);
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator"coordinateSystem"theCoordinateSystem), currentHashCodetheCoordinateSystem);
         }
         {
             List<CTCoordinateSystemAxisPropertyTypetheAxis;
             theAxis = (((this.!= null)&&(!this..isEmpty()))?this.getAxis():null);
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator"axis"theAxis), currentHashCodetheAxis);
         }
         {
             List<CTDatumPropertyTypetheDatum;
             theDatum = (((this.!= null)&&(!this..isEmpty()))?this.getDatum():null);
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator"datum"theDatum), currentHashCodetheDatum);
         }
         {
             List<CTEllipsoidPropertyTypetheEllipsoid;
             theEllipsoid = (((this.!= null)&&(!this..isEmpty()))?this.getEllipsoid():null);
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator"ellipsoid"theEllipsoid), currentHashCodetheEllipsoid);
         }
         {
             List<CTPrimeMeridianPropertyTypethePrimeMeridian;
             thePrimeMeridian = (((this.!= null)&&(!this..isEmpty()))?this.getPrimeMeridian():null);
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator"primeMeridian"thePrimeMeridian), currentHashCodethePrimeMeridian);
         }
         {
             List<CTOperationPropertyTypetheOperation;
             theOperation = (((this.!= null)&&(!this..isEmpty()))?this.getOperation():null);
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator"operation"theOperation), currentHashCodetheOperation);
         }
         {
             List<CTOperationMethodPropertyTypetheOperationMethod;
             theOperationMethod = (((this.!= null)&&(!this..isEmpty()))?this.getOperationMethod():null);
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator"operationMethod"theOperationMethod), currentHashCodetheOperationMethod);
         }
         {
             List<CTOperationParametersPropertyTypetheParameters;
             theParameters = (((this.!= null)&&(!this..isEmpty()))?this.getParameters():null);
             currentHashCode = strategy.hashCode(LocatorUtils.property(locator"parameters"theParameters), currentHashCodetheParameters);
         }
         return currentHashCode;
     }
 
     public int hashCode() {
         final HashCodeStrategy strategy = .;
         return this.hashCode(nullstrategy);
     }
 
     public Object clone() {
         return copyTo(createNewInstance());
     }
 
     public Object copyTo(Object target) {
         final CopyStrategy strategy = .;
         return copyTo(nulltargetstrategy);
     }
 
     public Object copyTo(ObjectLocator locatorObject targetCopyStrategy strategy) {
         final Object draftCopy = ((target == null)?createNewInstance():target);
         super.copyTo(locatordraftCopystrategy);
         if (draftCopy instanceof CTCrsCatalogueType) {
             final CTCrsCatalogueType copy = ((CTCrsCatalogueTypedraftCopy);
             if ((this.!= null)&&(!this..isEmpty())) {
                 List<CTCRSPropertyTypesourceCrs;
                 sourceCrs = (((this.!= null)&&(!this..isEmpty()))?this.getCrs():null);
                 @SuppressWarnings("unchecked")
                 List<CTCRSPropertyTypecopyCrs = ((List<CTCRSPropertyType> ) strategy.copy(LocatorUtils.property(locator"crs"sourceCrs), sourceCrs));
                 copy.crs = null;
                 if (copyCrs!= null) {
                     List<CTCRSPropertyTypeuniqueCrsl = copy.getCrs();
                     uniqueCrsl.addAll(copyCrs);
                 }
             } else {
                 copy.crs = null;
             }
             if ((this.!= null)&&(!this..isEmpty())) {
                 List<CTCoordinateSystemPropertyTypesourceCoordinateSystem;
                 sourceCoordinateSystem = (((this.!= null)&&(!this..isEmpty()))?this.getCoordinateSystem():null);
                 @SuppressWarnings("unchecked")
                 List<CTCoordinateSystemPropertyTypecopyCoordinateSystem = ((List<CTCoordinateSystemPropertyType> ) strategy.copy(LocatorUtils.property(locator"coordinateSystem"sourceCoordinateSystem), sourceCoordinateSystem));
                 copy.coordinateSystem = null;
                 if (copyCoordinateSystem!= null) {
                     List<CTCoordinateSystemPropertyTypeuniqueCoordinateSysteml = copy.getCoordinateSystem();
                     uniqueCoordinateSysteml.addAll(copyCoordinateSystem);
                 }
             } else {
                 copy.coordinateSystem = null;
             }
             if ((this.!= null)&&(!this..isEmpty())) {
                 List<CTCoordinateSystemAxisPropertyTypesourceAxis;
                 sourceAxis = (((this.!= null)&&(!this..isEmpty()))?this.getAxis():null);
                 @SuppressWarnings("unchecked")
                 List<CTCoordinateSystemAxisPropertyTypecopyAxis = ((List<CTCoordinateSystemAxisPropertyType> ) strategy.copy(LocatorUtils.property(locator"axis"sourceAxis), sourceAxis));
                 copy.axis = null;
                 if (copyAxis!= null) {
                     List<CTCoordinateSystemAxisPropertyTypeuniqueAxisl = copy.getAxis();
                     uniqueAxisl.addAll(copyAxis);
                 }
             } else {
                 copy.axis = null;
             }
             if ((this.!= null)&&(!this..isEmpty())) {
                 List<CTDatumPropertyTypesourceDatum;
                 sourceDatum = (((this.!= null)&&(!this..isEmpty()))?this.getDatum():null);
                 @SuppressWarnings("unchecked")
                 List<CTDatumPropertyTypecopyDatum = ((List<CTDatumPropertyType> ) strategy.copy(LocatorUtils.property(locator"datum"sourceDatum), sourceDatum));
                 copy.datum = null;
                 if (copyDatum!= null) {
                     List<CTDatumPropertyTypeuniqueDatuml = copy.getDatum();
                     uniqueDatuml.addAll(copyDatum);
                 }
             } else {
                 copy.datum = null;
             }
             if ((this.!= null)&&(!this..isEmpty())) {
                 List<CTEllipsoidPropertyTypesourceEllipsoid;
                 sourceEllipsoid = (((this.!= null)&&(!this..isEmpty()))?this.getEllipsoid():null);
                 @SuppressWarnings("unchecked")
                 List<CTEllipsoidPropertyTypecopyEllipsoid = ((List<CTEllipsoidPropertyType> ) strategy.copy(LocatorUtils.property(locator"ellipsoid"sourceEllipsoid), sourceEllipsoid));
                 copy.ellipsoid = null;
                 if (copyEllipsoid!= null) {
                     List<CTEllipsoidPropertyTypeuniqueEllipsoidl = copy.getEllipsoid();
                     uniqueEllipsoidl.addAll(copyEllipsoid);
                 }
             } else {
                 copy.ellipsoid = null;
             }
             if ((this.!= null)&&(!this..isEmpty())) {
                 List<CTPrimeMeridianPropertyTypesourcePrimeMeridian;
                 sourcePrimeMeridian = (((this.!= null)&&(!this..isEmpty()))?this.getPrimeMeridian():null);
                 @SuppressWarnings("unchecked")
                 List<CTPrimeMeridianPropertyTypecopyPrimeMeridian = ((List<CTPrimeMeridianPropertyType> ) strategy.copy(LocatorUtils.property(locator"primeMeridian"sourcePrimeMeridian), sourcePrimeMeridian));
                 copy.primeMeridian = null;
                 if (copyPrimeMeridian!= null) {
                     List<CTPrimeMeridianPropertyTypeuniquePrimeMeridianl = copy.getPrimeMeridian();
                     uniquePrimeMeridianl.addAll(copyPrimeMeridian);
                 }
             } else {
                 copy.primeMeridian = null;
             }
             if ((this.!= null)&&(!this..isEmpty())) {
                 List<CTOperationPropertyTypesourceOperation;
                 sourceOperation = (((this.!= null)&&(!this..isEmpty()))?this.getOperation():null);
                 @SuppressWarnings("unchecked")
                 List<CTOperationPropertyTypecopyOperation = ((List<CTOperationPropertyType> ) strategy.copy(LocatorUtils.property(locator"operation"sourceOperation), sourceOperation));
                 copy.operation = null;
                 if (copyOperation!= null) {
                     List<CTOperationPropertyTypeuniqueOperationl = copy.getOperation();
                     uniqueOperationl.addAll(copyOperation);
                 }
             } else {
                 copy.operation = null;
             }
             if ((this.!= null)&&(!this..isEmpty())) {
                 List<CTOperationMethodPropertyTypesourceOperationMethod;
                 sourceOperationMethod = (((this.!= null)&&(!this..isEmpty()))?this.getOperationMethod():null);
                 @SuppressWarnings("unchecked")
                 List<CTOperationMethodPropertyTypecopyOperationMethod = ((List<CTOperationMethodPropertyType> ) strategy.copy(LocatorUtils.property(locator"operationMethod"sourceOperationMethod), sourceOperationMethod));
                 copy.operationMethod = null;
                 if (copyOperationMethod!= null) {
                     List<CTOperationMethodPropertyTypeuniqueOperationMethodl = copy.getOperationMethod();
                     uniqueOperationMethodl.addAll(copyOperationMethod);
                 }
             } else {
                 copy.operationMethod = null;
             }
             if ((this.!= null)&&(!this..isEmpty())) {
                 List<CTOperationParametersPropertyTypesourceParameters;
                 sourceParameters = (((this.!= null)&&(!this..isEmpty()))?this.getParameters():null);
                 @SuppressWarnings("unchecked")
                 List<CTOperationParametersPropertyTypecopyParameters = ((List<CTOperationParametersPropertyType> ) strategy.copy(LocatorUtils.property(locator"parameters"sourceParameters), sourceParameters));
                 copy.parameters = null;
                 if (copyParameters!= null) {
                     List<CTOperationParametersPropertyTypeuniqueParametersl = copy.getParameters();
                     uniqueParametersl.addAll(copyParameters);
                 }
             } else {
                 copy.parameters = null;
             }
         }
         return draftCopy;
     }
 
     public Object createNewInstance() {
         return new CTCrsCatalogueType();
     }
 
     public void mergeFrom(Object leftObject right) {
         final MergeStrategy strategy = .;
         mergeFrom(nullnullleftrightstrategy);
     }
 
     public void mergeFrom(ObjectLocator leftLocatorObjectLocator rightLocatorObject leftObject rightMergeStrategy strategy) {
         super.mergeFrom(leftLocatorrightLocatorleftrightstrategy);
         if (right instanceof CTCrsCatalogueType) {
             final CTCrsCatalogueType target = this;
             final CTCrsCatalogueType leftObject = ((CTCrsCatalogueTypeleft);
             final CTCrsCatalogueType rightObject = ((CTCrsCatalogueTyperight);
             {
                 List<CTCRSPropertyTypelhsCrs;
                 lhsCrs = (((leftObject.crs!= null)&&(!leftObject.crs.isEmpty()))?leftObject.getCrs():null);
                 List<CTCRSPropertyTyperhsCrs;
                 rhsCrs = (((rightObject.crs!= null)&&(!rightObject.crs.isEmpty()))?rightObject.getCrs():null);
                 List<CTCRSPropertyTypemergedCrs = ((List<CTCRSPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"crs"lhsCrs), LocatorUtils.property(rightLocator"crs"rhsCrs), lhsCrsrhsCrs));
                 target.crs = null;
                 if (mergedCrs!= null) {
                     List<CTCRSPropertyTypeuniqueCrsl = target.getCrs();
                     uniqueCrsl.addAll(mergedCrs);
                 }
             }
             {
                 List<CTCoordinateSystemPropertyTypelhsCoordinateSystem;
                 lhsCoordinateSystem = (((leftObject.coordinateSystem!= null)&&(!leftObject.coordinateSystem.isEmpty()))?leftObject.getCoordinateSystem():null);
                 List<CTCoordinateSystemPropertyTyperhsCoordinateSystem;
                 rhsCoordinateSystem = (((rightObject.coordinateSystem!= null)&&(!rightObject.coordinateSystem.isEmpty()))?rightObject.getCoordinateSystem():null);
                 List<CTCoordinateSystemPropertyTypemergedCoordinateSystem = ((List<CTCoordinateSystemPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"coordinateSystem"lhsCoordinateSystem), LocatorUtils.property(rightLocator"coordinateSystem"rhsCoordinateSystem), lhsCoordinateSystemrhsCoordinateSystem));
                 target.coordinateSystem = null;
                 if (mergedCoordinateSystem!= null) {
                     List<CTCoordinateSystemPropertyTypeuniqueCoordinateSysteml = target.getCoordinateSystem();
                     uniqueCoordinateSysteml.addAll(mergedCoordinateSystem);
                 }
             }
             {
                 List<CTCoordinateSystemAxisPropertyTypelhsAxis;
                 lhsAxis = (((leftObject.axis!= null)&&(!leftObject.axis.isEmpty()))?leftObject.getAxis():null);
                 List<CTCoordinateSystemAxisPropertyTyperhsAxis;
                 rhsAxis = (((rightObject.axis!= null)&&(!rightObject.axis.isEmpty()))?rightObject.getAxis():null);
                 List<CTCoordinateSystemAxisPropertyTypemergedAxis = ((List<CTCoordinateSystemAxisPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"axis"lhsAxis), LocatorUtils.property(rightLocator"axis"rhsAxis), lhsAxisrhsAxis));
                 target.axis = null;
                 if (mergedAxis!= null) {
                     List<CTCoordinateSystemAxisPropertyTypeuniqueAxisl = target.getAxis();
                     uniqueAxisl.addAll(mergedAxis);
                 }
             }
             {
                 List<CTDatumPropertyTypelhsDatum;
                 lhsDatum = (((leftObject.datum!= null)&&(!leftObject.datum.isEmpty()))?leftObject.getDatum():null);
                 List<CTDatumPropertyTyperhsDatum;
                 rhsDatum = (((rightObject.datum!= null)&&(!rightObject.datum.isEmpty()))?rightObject.getDatum():null);
                 List<CTDatumPropertyTypemergedDatum = ((List<CTDatumPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"datum"lhsDatum), LocatorUtils.property(rightLocator"datum"rhsDatum), lhsDatumrhsDatum));
                 target.datum = null;
                 if (mergedDatum!= null) {
                     List<CTDatumPropertyTypeuniqueDatuml = target.getDatum();
                     uniqueDatuml.addAll(mergedDatum);
                 }
             }
             {
                 List<CTEllipsoidPropertyTypelhsEllipsoid;
                 lhsEllipsoid = (((leftObject.ellipsoid!= null)&&(!leftObject.ellipsoid.isEmpty()))?leftObject.getEllipsoid():null);
                 List<CTEllipsoidPropertyTyperhsEllipsoid;
                 rhsEllipsoid = (((rightObject.ellipsoid!= null)&&(!rightObject.ellipsoid.isEmpty()))?rightObject.getEllipsoid():null);
                 List<CTEllipsoidPropertyTypemergedEllipsoid = ((List<CTEllipsoidPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"ellipsoid"lhsEllipsoid), LocatorUtils.property(rightLocator"ellipsoid"rhsEllipsoid), lhsEllipsoidrhsEllipsoid));
                 target.ellipsoid = null;
                 if (mergedEllipsoid!= null) {
                     List<CTEllipsoidPropertyTypeuniqueEllipsoidl = target.getEllipsoid();
                     uniqueEllipsoidl.addAll(mergedEllipsoid);
                 }
             }
             {
                 List<CTPrimeMeridianPropertyTypelhsPrimeMeridian;
                 lhsPrimeMeridian = (((leftObject.primeMeridian!= null)&&(!leftObject.primeMeridian.isEmpty()))?leftObject.getPrimeMeridian():null);
                 List<CTPrimeMeridianPropertyTyperhsPrimeMeridian;
                 rhsPrimeMeridian = (((rightObject.primeMeridian!= null)&&(!rightObject.primeMeridian.isEmpty()))?rightObject.getPrimeMeridian():null);
                 List<CTPrimeMeridianPropertyTypemergedPrimeMeridian = ((List<CTPrimeMeridianPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"primeMeridian"lhsPrimeMeridian), LocatorUtils.property(rightLocator"primeMeridian"rhsPrimeMeridian), lhsPrimeMeridianrhsPrimeMeridian));
                 target.primeMeridian = null;
                 if (mergedPrimeMeridian!= null) {
                     List<CTPrimeMeridianPropertyTypeuniquePrimeMeridianl = target.getPrimeMeridian();
                     uniquePrimeMeridianl.addAll(mergedPrimeMeridian);
                 }
             }
             {
                 List<CTOperationPropertyTypelhsOperation;
                 lhsOperation = (((leftObject.operation!= null)&&(!leftObject.operation.isEmpty()))?leftObject.getOperation():null);
                 List<CTOperationPropertyTyperhsOperation;
                 rhsOperation = (((rightObject.operation!= null)&&(!rightObject.operation.isEmpty()))?rightObject.getOperation():null);
                 List<CTOperationPropertyTypemergedOperation = ((List<CTOperationPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"operation"lhsOperation), LocatorUtils.property(rightLocator"operation"rhsOperation), lhsOperationrhsOperation));
                 target.operation = null;
                 if (mergedOperation!= null) {
                     List<CTOperationPropertyTypeuniqueOperationl = target.getOperation();
                     uniqueOperationl.addAll(mergedOperation);
                 }
             }
             {
                 List<CTOperationMethodPropertyTypelhsOperationMethod;
                 lhsOperationMethod = (((leftObject.operationMethod!= null)&&(!leftObject.operationMethod.isEmpty()))?leftObject.getOperationMethod():null);
                 List<CTOperationMethodPropertyTyperhsOperationMethod;
                 rhsOperationMethod = (((rightObject.operationMethod!= null)&&(!rightObject.operationMethod.isEmpty()))?rightObject.getOperationMethod():null);
                 List<CTOperationMethodPropertyTypemergedOperationMethod = ((List<CTOperationMethodPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"operationMethod"lhsOperationMethod), LocatorUtils.property(rightLocator"operationMethod"rhsOperationMethod), lhsOperationMethodrhsOperationMethod));
                 target.operationMethod = null;
                 if (mergedOperationMethod!= null) {
                     List<CTOperationMethodPropertyTypeuniqueOperationMethodl = target.getOperationMethod();
                     uniqueOperationMethodl.addAll(mergedOperationMethod);
                 }
             }
             {
                 List<CTOperationParametersPropertyTypelhsParameters;
                 lhsParameters = (((leftObject.parameters!= null)&&(!leftObject.parameters.isEmpty()))?leftObject.getParameters():null);
                 List<CTOperationParametersPropertyTyperhsParameters;
                 rhsParameters = (((rightObject.parameters!= null)&&(!rightObject.parameters.isEmpty()))?rightObject.getParameters():null);
                 List<CTOperationParametersPropertyTypemergedParameters = ((List<CTOperationParametersPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"parameters"lhsParameters), LocatorUtils.property(rightLocator"parameters"rhsParameters), lhsParametersrhsParameters));
                 target.parameters = null;
                 if (mergedParameters!= null) {
                     List<CTOperationParametersPropertyTypeuniqueParametersl = target.getParameters();
                     uniqueParametersl.addAll(mergedParameters);
                 }
             }
         }
     }
 
     public void setCrs(List<CTCRSPropertyTypevalue) {
         this. = null;
         List<CTCRSPropertyTypedraftl = this.getCrs();
         draftl.addAll(value);
     }
 
     public void setCoordinateSystem(List<CTCoordinateSystemPropertyTypevalue) {
         this. = null;
         List<CTCoordinateSystemPropertyTypedraftl = this.getCoordinateSystem();
         draftl.addAll(value);
     }
 
     public void setAxis(List<CTCoordinateSystemAxisPropertyTypevalue) {
         this. = null;
         List<CTCoordinateSystemAxisPropertyTypedraftl = this.getAxis();
         draftl.addAll(value);
     }
 
     public void setDatum(List<CTDatumPropertyTypevalue) {
         this. = null;
         List<CTDatumPropertyTypedraftl = this.getDatum();
         draftl.addAll(value);
     }
 
     public void setEllipsoid(List<CTEllipsoidPropertyTypevalue) {
         this. = null;
         List<CTEllipsoidPropertyTypedraftl = this.getEllipsoid();
         draftl.addAll(value);
     }
 
     public void setPrimeMeridian(List<CTPrimeMeridianPropertyTypevalue) {
         this. = null;
         List<CTPrimeMeridianPropertyTypedraftl = this.getPrimeMeridian();
         draftl.addAll(value);
     }
 
     public void setOperation(List<CTOperationPropertyTypevalue) {
         this. = null;
         List<CTOperationPropertyTypedraftl = this.getOperation();
         draftl.addAll(value);
     }
 
     public void setOperationMethod(List<CTOperationMethodPropertyTypevalue) {
         this. = null;
         List<CTOperationMethodPropertyTypedraftl = this.getOperationMethod();
         draftl.addAll(value);
     }
 
     public void setParameters(List<CTOperationParametersPropertyTypevalue) {
         this. = null;
         List<CTOperationParametersPropertyTypedraftl = this.getParameters();
         draftl.addAll(value);
     }
 
     public CTCrsCatalogueType withCrs(CTCRSPropertyType... values) {
         if (values!= null) {
             for (CTCRSPropertyType valuevalues) {
                 getCrs().add(value);
             }
         }
         return this;
     }
 
         if (values!= null) {
             getCrs().addAll(values);
         }
         return this;
     }
 
         if (values!= null) {
             for (CTCoordinateSystemPropertyType valuevalues) {
                 getCoordinateSystem().add(value);
             }
         }
         return this;
     }
 
         if (values!= null) {
             getCoordinateSystem().addAll(values);
         }
         return this;
     }
 
         if (values!= null) {
             for (CTCoordinateSystemAxisPropertyType valuevalues) {
                 getAxis().add(value);
             }
         }
         return this;
     }
 
         if (values!= null) {
             getAxis().addAll(values);
         }
         return this;
     }
 
     public CTCrsCatalogueType withDatum(CTDatumPropertyType... values) {
         if (values!= null) {
             for (CTDatumPropertyType valuevalues) {
                 getDatum().add(value);
             }
         }
         return this;
     }
 
         if (values!= null) {
             getDatum().addAll(values);
         }
         return this;
     }
 
         if (values!= null) {
             for (CTEllipsoidPropertyType valuevalues) {
                 getEllipsoid().add(value);
             }
         }
         return this;
     }
 
         if (values!= null) {
             getEllipsoid().addAll(values);
         }
         return this;
     }
 
         if (values!= null) {
             for (CTPrimeMeridianPropertyType valuevalues) {
                 getPrimeMeridian().add(value);
             }
         }
         return this;
     }
 
         if (values!= null) {
             getPrimeMeridian().addAll(values);
         }
         return this;
     }
 
         if (values!= null) {
             for (CTOperationPropertyType valuevalues) {
                 getOperation().add(value);
             }
         }
         return this;
     }
 
         if (values!= null) {
             getOperation().addAll(values);
         }
        return this;
    }
        if (values!= null) {
            for (CTOperationMethodPropertyType valuevalues) {
                getOperationMethod().add(value);
            }
        }
        return this;
    }
        if (values!= null) {
            getOperationMethod().addAll(values);
        }
        return this;
    }
        if (values!= null) {
            for (CTOperationParametersPropertyType valuevalues) {
                getParameters().add(value);
            }
        }
        return this;
    }
        if (values!= null) {
            getParameters().addAll(values);
        }
        return this;
    }
        setCrs(value);
        return this;
    }
        setCoordinateSystem(value);
        return this;
    }
        setAxis(value);
        return this;
    }
        setDatum(value);
        return this;
    }
        setEllipsoid(value);
        return this;
    }
        setPrimeMeridian(value);
        return this;
    }
        setOperation(value);
        return this;
    }
        setOperationMethod(value);
        return this;
    }
        setParameters(value);
        return this;
    }
    @Override
        setName(value);
        return this;
    }
    @Override
        if (values!= null) {
            for (CharacterStringPropertyType valuevalues) {
                getScope().add(value);
            }
        }
        return this;
    }
    @Override