public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   if (draftCopy instanceof TopoCurvePropertyType) {
     final TopoCurvePropertyType copy = ((TopoCurvePropertyType) draftCopy);
     if (this.isSetTopoCurve()) {
       TopoCurveType sourceTopoCurve;
       sourceTopoCurve = this.getTopoCurve();
       TopoCurveType copyTopoCurve =
           ((TopoCurveType)
               strategy.copy(
                   LocatorUtils.property(locator, "topoCurve", sourceTopoCurve), sourceTopoCurve));
       copy.setTopoCurve(copyTopoCurve);
     } else {
       copy.topoCurve = null;
     }
     if (this.isSetOwns()) {
       boolean sourceOwns;
       sourceOwns = this.isOwns();
       boolean copyOwns =
           strategy.copy(LocatorUtils.property(locator, "owns", sourceOwns), sourceOwns);
       copy.setOwns(copyOwns);
     } else {
       copy.unsetOwns();
     }
   }
   return draftCopy;
 }
Esempio n. 2
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof PolygonType) {
     final PolygonType copy = ((PolygonType) draftCopy);
     if (this.isSetExterior()) {
       AbstractRingPropertyType sourceExterior;
       sourceExterior = this.getExterior();
       AbstractRingPropertyType copyExterior =
           ((AbstractRingPropertyType)
               strategy.copy(
                   LocatorUtils.property(locator, "exterior", sourceExterior), sourceExterior));
       copy.setExterior(copyExterior);
     } else {
       copy.exterior = null;
     }
     if (this.isSetInteriors()) {
       List<AbstractRingPropertyType> sourceInteriors;
       sourceInteriors = (this.isSetInteriors() ? this.getInteriors() : null);
       @SuppressWarnings("unchecked")
       List<AbstractRingPropertyType> copyInteriors =
           ((List<AbstractRingPropertyType>)
               strategy.copy(
                   LocatorUtils.property(locator, "interiors", sourceInteriors), sourceInteriors));
       copy.unsetInteriors();
       List<AbstractRingPropertyType> uniqueInteriorsl = copy.getInteriors();
       uniqueInteriorsl.addAll(copyInteriors);
     } else {
       copy.unsetInteriors();
     }
   }
   return draftCopy;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof CompositeSurfaceType) {
     final CompositeSurfaceType copy = ((CompositeSurfaceType) draftCopy);
     if (this.isSetSurfaceMember()) {
       List<SurfacePropertyType> sourceSurfaceMember;
       sourceSurfaceMember = this.getSurfaceMember();
       @SuppressWarnings("unchecked")
       List<SurfacePropertyType> copySurfaceMember =
           ((List<SurfacePropertyType>)
               strategy.copy(
                   LocatorUtils.property(locator, "surfaceMember", sourceSurfaceMember),
                   sourceSurfaceMember));
       copy.unsetSurfaceMember();
       List<SurfacePropertyType> uniqueSurfaceMemberl = copy.getSurfaceMember();
       uniqueSurfaceMemberl.addAll(copySurfaceMember);
     } else {
       copy.unsetSurfaceMember();
     }
     if (this.isSetAggregationType()) {
       AggregationType sourceAggregationType;
       sourceAggregationType = this.getAggregationType();
       AggregationType copyAggregationType =
           ((AggregationType)
               strategy.copy(
                   LocatorUtils.property(locator, "aggregationType", sourceAggregationType),
                   sourceAggregationType));
       copy.setAggregationType(copyAggregationType);
     } else {
       copy.aggregationType = null;
     }
   }
   return draftCopy;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   if (null == target) {
     throw new IllegalArgumentException(
         "Target argument must not be null for abstract copyable classes.");
   }
   super.copyTo(locator, target, strategy);
   if (target instanceof AbstractCoverageType) {
     final AbstractCoverageType copy = ((AbstractCoverageType) target);
     if (this.isSetDomainSet()) {
       JAXBElement<? extends DomainSetType> sourceDomainSet;
       sourceDomainSet = this.getDomainSet();
       @SuppressWarnings("unchecked")
       JAXBElement<? extends DomainSetType> copyDomainSet =
           ((JAXBElement<? extends DomainSetType>)
               strategy.copy(
                   LocatorUtils.property(locator, "domainSet", sourceDomainSet), sourceDomainSet));
       copy.setDomainSet(copyDomainSet);
     } else {
       copy.domainSet = null;
     }
     if (this.isSetRangeSet()) {
       RangeSetType sourceRangeSet;
       sourceRangeSet = this.getRangeSet();
       RangeSetType copyRangeSet =
           ((RangeSetType)
               strategy.copy(
                   LocatorUtils.property(locator, "rangeSet", sourceRangeSet), sourceRangeSet));
       copy.setRangeSet(copyRangeSet);
     } else {
       copy.rangeSet = null;
     }
   }
   return target;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   if (draftCopy instanceof LandSizeType) {
     final LandSizeType copy = ((LandSizeType) draftCopy);
     if (this.value != null) {
       Long sourceValue;
       sourceValue = this.getValue();
       Long copyValue =
           ((Long)
               strategy.copy(LocatorUtils.property(locator, "value", sourceValue), sourceValue));
       copy.setValue(copyValue);
     } else {
       copy.value = null;
     }
     if (this.unit != null) {
       LandSizeUnit sourceUnit;
       sourceUnit = this.getUnit();
       LandSizeUnit copyUnit =
           ((LandSizeUnit)
               strategy.copy(LocatorUtils.property(locator, "unit", sourceUnit), sourceUnit));
       copy.setUnit(copyUnit);
     } else {
       copy.unit = null;
     }
   }
   return draftCopy;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   if (draftCopy instanceof WSIWmsServer) {
     final WSIWmsServer copy = ((WSIWmsServer) draftCopy);
     if (this.isSetName()) {
       String sourceName;
       sourceName = this.getName();
       String copyName =
           ((String)
               strategy.copy(LocatorUtils.property(locator, "name", sourceName), sourceName));
       copy.setName(copyName);
     } else {
       copy.name = null;
     }
     if (this.isSetUrl()) {
       String sourceUrl;
       sourceUrl = this.getUrl();
       String copyUrl =
           ((String) strategy.copy(LocatorUtils.property(locator, "url", sourceUrl), sourceUrl));
       copy.setUrl(copyUrl);
     } else {
       copy.url = null;
     }
   }
   return draftCopy;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof TopoVolumeType) {
     final TopoVolumeType copy = ((TopoVolumeType) draftCopy);
     if (this.isSetDirectedTopoSolid()) {
       List<DirectedTopoSolidPropertyType> sourceDirectedTopoSolid;
       sourceDirectedTopoSolid = this.getDirectedTopoSolid();
       @SuppressWarnings("unchecked")
       List<DirectedTopoSolidPropertyType> copyDirectedTopoSolid =
           ((List<DirectedTopoSolidPropertyType>)
               strategy.copy(
                   LocatorUtils.property(locator, "directedTopoSolid", sourceDirectedTopoSolid),
                   sourceDirectedTopoSolid));
       copy.unsetDirectedTopoSolid();
       List<DirectedTopoSolidPropertyType> uniqueDirectedTopoSolidl = copy.getDirectedTopoSolid();
       uniqueDirectedTopoSolidl.addAll(copyDirectedTopoSolid);
     } else {
       copy.unsetDirectedTopoSolid();
     }
     if (this.isSetAggregationType()) {
       AggregationType sourceAggregationType;
       sourceAggregationType = this.getAggregationType();
       AggregationType copyAggregationType =
           ((AggregationType)
               strategy.copy(
                   LocatorUtils.property(locator, "aggregationType", sourceAggregationType),
                   sourceAggregationType));
       copy.setAggregationType(copyAggregationType);
     } else {
       copy.aggregationType = null;
     }
   }
   return draftCopy;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   if (null == target) {
     throw new IllegalArgumentException(
         "Target argument must not be null for abstract copyable classes.");
   }
   super.copyTo(locator, target, strategy);
   if (target instanceof AbstractTimePrimitiveType) {
     final AbstractTimePrimitiveType copy = ((AbstractTimePrimitiveType) target);
     if (this.isSetRelatedTime()) {
       List<RelatedTimeType> sourceRelatedTime;
       sourceRelatedTime = this.getRelatedTime();
       @SuppressWarnings("unchecked")
       List<RelatedTimeType> copyRelatedTime =
           ((List<RelatedTimeType>)
               strategy.copy(
                   LocatorUtils.property(locator, "relatedTime", sourceRelatedTime),
                   sourceRelatedTime));
       copy.unsetRelatedTime();
       List<RelatedTimeType> uniqueRelatedTimel = copy.getRelatedTime();
       uniqueRelatedTimel.addAll(copyRelatedTime);
     } else {
       copy.unsetRelatedTime();
     }
   }
   return target;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   if (draftCopy instanceof ScriptExecutionDetails) {
     final ScriptExecutionDetails copy = ((ScriptExecutionDetails) draftCopy);
     if (this.inlineScript != null) {
       String sourceInlineScript;
       sourceInlineScript = this.getInlineScript();
       String copyInlineScript =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "inlineScript", sourceInlineScript),
                   sourceInlineScript));
       copy.setInlineScript(copyInlineScript);
     } else {
       copy.inlineScript = null;
     }
   }
   return draftCopy;
 }
Esempio n. 10
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof RectangleType) {
     final RectangleType copy = ((RectangleType) draftCopy);
     if (this.isSetExterior()) {
       AbstractRingPropertyType sourceExterior;
       sourceExterior = this.getExterior();
       AbstractRingPropertyType copyExterior =
           ((AbstractRingPropertyType)
               strategy.copy(
                   LocatorUtils.property(locator, "exterior", sourceExterior), sourceExterior));
       copy.setExterior(copyExterior);
     } else {
       copy.exterior = null;
     }
   }
   return draftCopy;
 }
Esempio n. 11
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof DefinitionType) {
     final DefinitionType copy = ((DefinitionType) draftCopy);
     if (this.isSetRemarks()) {
       String sourceRemarks;
       sourceRemarks = this.getRemarks();
       String copyRemarks =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "remarks", sourceRemarks), sourceRemarks));
       copy.setRemarks(copyRemarks);
     } else {
       copy.remarks = null;
     }
   }
   return draftCopy;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   if (draftCopy instanceof IndirectEntryType) {
     final IndirectEntryType copy = ((IndirectEntryType) draftCopy);
     if (this.isSetDefinitionProxy()) {
       DefinitionProxyType sourceDefinitionProxy;
       sourceDefinitionProxy = this.getDefinitionProxy();
       DefinitionProxyType copyDefinitionProxy =
           ((DefinitionProxyType)
               strategy.copy(
                   LocatorUtils.property(locator, "definitionProxy", sourceDefinitionProxy),
                   sourceDefinitionProxy));
       copy.setDefinitionProxy(copyDefinitionProxy);
     } else {
       copy.definitionProxy = null;
     }
   }
   return draftCopy;
 }
Esempio n. 13
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof SurfaceType) {
     final SurfaceType copy = ((SurfaceType) draftCopy);
     if (this.isSetPatches()) {
       JAXBElement<? extends SurfacePatchArrayPropertyType> sourcePatches;
       sourcePatches = this.getPatches();
       @SuppressWarnings("unchecked")
       JAXBElement<? extends SurfacePatchArrayPropertyType> copyPatches =
           ((JAXBElement<? extends SurfacePatchArrayPropertyType>)
               strategy.copy(
                   LocatorUtils.property(locator, "patches", sourcePatches), sourcePatches));
       copy.setPatches(copyPatches);
     } else {
       copy.patches = null;
     }
   }
   return draftCopy;
 }
Esempio n. 14
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof RelatedTimeType) {
     final RelatedTimeType copy = ((RelatedTimeType) draftCopy);
     if (this.isSetRelativePosition()) {
       String sourceRelativePosition;
       sourceRelativePosition = this.getRelativePosition();
       String copyRelativePosition =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "relativePosition", sourceRelativePosition),
                   sourceRelativePosition));
       copy.setRelativePosition(copyRelativePosition);
     } else {
       copy.relativePosition = null;
     }
   }
   return draftCopy;
 }
Esempio n. 15
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   if (draftCopy instanceof Pictures) {
     final Pictures copy = ((Pictures) draftCopy);
     if ((this.picture != null) && (!this.picture.isEmpty())) {
       List<Picture> sourcePicture;
       sourcePicture =
           (((this.picture != null) && (!this.picture.isEmpty())) ? this.getPicture() : null);
       @SuppressWarnings("unchecked")
       List<Picture> copyPicture =
           ((List<Picture>)
               strategy.copy(
                   LocatorUtils.property(locator, "picture", sourcePicture), sourcePicture));
       copy.picture = null;
       if (copyPicture != null) {
         List<Picture> uniquePicturel = copy.getPicture();
         uniquePicturel.addAll(copyPicture);
       }
     } else {
       copy.picture = null;
     }
   }
   return draftCopy;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   if (draftCopy instanceof ZustandAngaben) {
     final ZustandAngaben copy = ((ZustandAngaben) draftCopy);
     if (this.baujahr != null) {
       String sourceBaujahr;
       sourceBaujahr = this.getBaujahr();
       String copyBaujahr =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "baujahr", sourceBaujahr), sourceBaujahr));
       copy.setBaujahr(copyBaujahr);
     } else {
       copy.baujahr = null;
     }
     if (this.zustand != null) {
       Zustand sourceZustand;
       sourceZustand = this.getZustand();
       Zustand copyZustand =
           ((Zustand)
               strategy.copy(
                   LocatorUtils.property(locator, "zustand", sourceZustand), sourceZustand));
       copy.setZustand(copyZustand);
     } else {
       copy.zustand = null;
     }
     if (this.alter != null) {
       Alter sourceAlter;
       sourceAlter = this.getAlter();
       Alter copyAlter =
           ((Alter)
               strategy.copy(LocatorUtils.property(locator, "alter", sourceAlter), sourceAlter));
       copy.setAlter(copyAlter);
     } else {
       copy.alter = null;
     }
     if (this.bebaubarNach != null) {
       BebaubarNach sourceBebaubarNach;
       sourceBebaubarNach = this.getBebaubarNach();
       BebaubarNach copyBebaubarNach =
           ((BebaubarNach)
               strategy.copy(
                   LocatorUtils.property(locator, "bebaubarNach", sourceBebaubarNach),
                   sourceBebaubarNach));
       copy.setBebaubarNach(copyBebaubarNach);
     } else {
       copy.bebaubarNach = null;
     }
     if (this.erschliessung != null) {
       Erschliessung sourceErschliessung;
       sourceErschliessung = this.getErschliessung();
       Erschliessung copyErschliessung =
           ((Erschliessung)
               strategy.copy(
                   LocatorUtils.property(locator, "erschliessung", sourceErschliessung),
                   sourceErschliessung));
       copy.setErschliessung(copyErschliessung);
     } else {
       copy.erschliessung = null;
     }
     if (this.altlasten != null) {
       String sourceAltlasten;
       sourceAltlasten = this.getAltlasten();
       String copyAltlasten =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "altlasten", sourceAltlasten), sourceAltlasten));
       copy.setAltlasten(copyAltlasten);
     } else {
       copy.altlasten = null;
     }
     if ((this.userDefinedSimplefield != null) && (!this.userDefinedSimplefield.isEmpty())) {
       List<UserDefinedSimplefield> sourceUserDefinedSimplefield;
       sourceUserDefinedSimplefield =
           (((this.userDefinedSimplefield != null) && (!this.userDefinedSimplefield.isEmpty()))
               ? this.getUserDefinedSimplefield()
               : null);
       @SuppressWarnings("unchecked")
       List<UserDefinedSimplefield> copyUserDefinedSimplefield =
           ((List<UserDefinedSimplefield>)
               strategy.copy(
                   LocatorUtils.property(
                       locator, "userDefinedSimplefield", sourceUserDefinedSimplefield),
                   sourceUserDefinedSimplefield));
       copy.userDefinedSimplefield = null;
       if (copyUserDefinedSimplefield != null) {
         List<UserDefinedSimplefield> uniqueUserDefinedSimplefieldl =
             copy.getUserDefinedSimplefield();
         uniqueUserDefinedSimplefieldl.addAll(copyUserDefinedSimplefield);
       }
     } else {
       copy.userDefinedSimplefield = null;
     }
     if ((this.userDefinedAnyfield != null) && (!this.userDefinedAnyfield.isEmpty())) {
       List<UserDefinedAnyfield> sourceUserDefinedAnyfield;
       sourceUserDefinedAnyfield =
           (((this.userDefinedAnyfield != null) && (!this.userDefinedAnyfield.isEmpty()))
               ? this.getUserDefinedAnyfield()
               : null);
       @SuppressWarnings("unchecked")
       List<UserDefinedAnyfield> copyUserDefinedAnyfield =
           ((List<UserDefinedAnyfield>)
               strategy.copy(
                   LocatorUtils.property(
                       locator, "userDefinedAnyfield", sourceUserDefinedAnyfield),
                   sourceUserDefinedAnyfield));
       copy.userDefinedAnyfield = null;
       if (copyUserDefinedAnyfield != null) {
         List<UserDefinedAnyfield> uniqueUserDefinedAnyfieldl = copy.getUserDefinedAnyfield();
         uniqueUserDefinedAnyfieldl.addAll(copyUserDefinedAnyfield);
       }
     } else {
       copy.userDefinedAnyfield = null;
     }
   }
   return draftCopy;
 }
Esempio n. 17
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof EdgeType) {
     final EdgeType copy = ((EdgeType) draftCopy);
     if (this.isSetDirectedNode()) {
       List<DirectedNodePropertyType> sourceDirectedNode;
       sourceDirectedNode = this.getDirectedNode();
       @SuppressWarnings("unchecked")
       List<DirectedNodePropertyType> copyDirectedNode =
           ((List<DirectedNodePropertyType>)
               strategy.copy(
                   LocatorUtils.property(locator, "directedNode", sourceDirectedNode),
                   sourceDirectedNode));
       copy.unsetDirectedNode();
       List<DirectedNodePropertyType> uniqueDirectedNodel = copy.getDirectedNode();
       uniqueDirectedNodel.addAll(copyDirectedNode);
     } else {
       copy.unsetDirectedNode();
     }
     if (this.isSetDirectedFace()) {
       List<DirectedFacePropertyType> sourceDirectedFace;
       sourceDirectedFace = this.getDirectedFace();
       @SuppressWarnings("unchecked")
       List<DirectedFacePropertyType> copyDirectedFace =
           ((List<DirectedFacePropertyType>)
               strategy.copy(
                   LocatorUtils.property(locator, "directedFace", sourceDirectedFace),
                   sourceDirectedFace));
       copy.unsetDirectedFace();
       List<DirectedFacePropertyType> uniqueDirectedFacel = copy.getDirectedFace();
       uniqueDirectedFacel.addAll(copyDirectedFace);
     } else {
       copy.unsetDirectedFace();
     }
     if (this.isSetCurveProperty()) {
       CurvePropertyType sourceCurveProperty;
       sourceCurveProperty = this.getCurveProperty();
       CurvePropertyType copyCurveProperty =
           ((CurvePropertyType)
               strategy.copy(
                   LocatorUtils.property(locator, "curveProperty", sourceCurveProperty),
                   sourceCurveProperty));
       copy.setCurveProperty(copyCurveProperty);
     } else {
       copy.curveProperty = null;
     }
     if (this.isSetAggregationType()) {
       AggregationType sourceAggregationType;
       sourceAggregationType = this.getAggregationType();
       AggregationType copyAggregationType =
           ((AggregationType)
               strategy.copy(
                   LocatorUtils.property(locator, "aggregationType", sourceAggregationType),
                   sourceAggregationType));
       copy.setAggregationType(copyAggregationType);
     } else {
       copy.aggregationType = null;
     }
   }
   return draftCopy;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   if (null == target) {
     throw new IllegalArgumentException(
         "Target argument must not be null for abstract copyable classes.");
   }
   super.copyTo(locator, target, strategy);
   if (target instanceof AbstractCoordinateOperationType) {
     final AbstractCoordinateOperationType copy = ((AbstractCoordinateOperationType) target);
     if (this.isSetDomainOfValidity()) {
       DomainOfValidityElement sourceDomainOfValidity;
       sourceDomainOfValidity = this.getDomainOfValidity();
       DomainOfValidityElement copyDomainOfValidity =
           ((DomainOfValidityElement)
               strategy.copy(
                   LocatorUtils.property(locator, "domainOfValidity", sourceDomainOfValidity),
                   sourceDomainOfValidity));
       copy.setDomainOfValidity(copyDomainOfValidity);
     } else {
       copy.domainOfValidity = null;
     }
     if (this.isSetScope()) {
       List<String> sourceScope;
       sourceScope = this.getScope();
       @SuppressWarnings("unchecked")
       List<String> copyScope =
           ((List<String>)
               strategy.copy(LocatorUtils.property(locator, "scope", sourceScope), sourceScope));
       copy.unsetScope();
       List<String> uniqueScopel = copy.getScope();
       uniqueScopel.addAll(copyScope);
     } else {
       copy.unsetScope();
     }
     if (this.isSetOperationVersion()) {
       String sourceOperationVersion;
       sourceOperationVersion = this.getOperationVersion();
       String copyOperationVersion =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "operationVersion", sourceOperationVersion),
                   sourceOperationVersion));
       copy.setOperationVersion(copyOperationVersion);
     } else {
       copy.operationVersion = null;
     }
     if (this.isSetCoordinateOperationAccuracy()) {
       List<CoordinateOperationAccuracyElement> sourceCoordinateOperationAccuracy;
       sourceCoordinateOperationAccuracy = this.getCoordinateOperationAccuracy();
       @SuppressWarnings("unchecked")
       List<CoordinateOperationAccuracyElement> copyCoordinateOperationAccuracy =
           ((List<CoordinateOperationAccuracyElement>)
               strategy.copy(
                   LocatorUtils.property(
                       locator, "coordinateOperationAccuracy", sourceCoordinateOperationAccuracy),
                   sourceCoordinateOperationAccuracy));
       copy.unsetCoordinateOperationAccuracy();
       List<CoordinateOperationAccuracyElement> uniqueCoordinateOperationAccuracyl =
           copy.getCoordinateOperationAccuracy();
       uniqueCoordinateOperationAccuracyl.addAll(copyCoordinateOperationAccuracy);
     } else {
       copy.unsetCoordinateOperationAccuracy();
     }
     if (this.isSetSourceCRS()) {
       CRSPropertyType sourceSourceCRS;
       sourceSourceCRS = this.getSourceCRS();
       CRSPropertyType copySourceCRS =
           ((CRSPropertyType)
               strategy.copy(
                   LocatorUtils.property(locator, "sourceCRS", sourceSourceCRS), sourceSourceCRS));
       copy.setSourceCRS(copySourceCRS);
     } else {
       copy.sourceCRS = null;
     }
     if (this.isSetTargetCRS()) {
       CRSPropertyType sourceTargetCRS;
       sourceTargetCRS = this.getTargetCRS();
       CRSPropertyType copyTargetCRS =
           ((CRSPropertyType)
               strategy.copy(
                   LocatorUtils.property(locator, "targetCRS", sourceTargetCRS), sourceTargetCRS));
       copy.setTargetCRS(copyTargetCRS);
     } else {
       copy.targetCRS = null;
     }
   }
   return target;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   if (draftCopy instanceof TimeCalendarEraPropertyType) {
     final TimeCalendarEraPropertyType copy = ((TimeCalendarEraPropertyType) draftCopy);
     if (this.isSetTimeCalendarEra()) {
       TimeCalendarEraType sourceTimeCalendarEra;
       sourceTimeCalendarEra = this.getTimeCalendarEra();
       TimeCalendarEraType copyTimeCalendarEra =
           ((TimeCalendarEraType)
               strategy.copy(
                   LocatorUtils.property(locator, "timeCalendarEra", sourceTimeCalendarEra),
                   sourceTimeCalendarEra));
       copy.setTimeCalendarEra(copyTimeCalendarEra);
     } else {
       copy.timeCalendarEra = null;
     }
     if (this.isSetOwns()) {
       boolean sourceOwns;
       sourceOwns = this.isOwns();
       boolean copyOwns =
           strategy.copy(LocatorUtils.property(locator, "owns", sourceOwns), sourceOwns);
       copy.setOwns(copyOwns);
     } else {
       copy.unsetOwns();
     }
     if (this.isSetNilReason()) {
       List<String> sourceNilReason;
       sourceNilReason = this.getNilReason();
       @SuppressWarnings("unchecked")
       List<String> copyNilReason =
           ((List<String>)
               strategy.copy(
                   LocatorUtils.property(locator, "nilReason", sourceNilReason), sourceNilReason));
       copy.unsetNilReason();
       List<String> uniqueNilReasonl = copy.getNilReason();
       uniqueNilReasonl.addAll(copyNilReason);
     } else {
       copy.unsetNilReason();
     }
     if (this.isSetRemoteSchema()) {
       String sourceRemoteSchema;
       sourceRemoteSchema = this.getRemoteSchema();
       String copyRemoteSchema =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "remoteSchema", sourceRemoteSchema),
                   sourceRemoteSchema));
       copy.setRemoteSchema(copyRemoteSchema);
     } else {
       copy.remoteSchema = null;
     }
     if (this.isSetHref()) {
       String sourceHref;
       sourceHref = this.getHref();
       String copyHref =
           ((String)
               strategy.copy(LocatorUtils.property(locator, "href", sourceHref), sourceHref));
       copy.setHref(copyHref);
     } else {
       copy.href = null;
     }
     if (this.isSetRole()) {
       String sourceRole;
       sourceRole = this.getRole();
       String copyRole =
           ((String)
               strategy.copy(LocatorUtils.property(locator, "role", sourceRole), sourceRole));
       copy.setRole(copyRole);
     } else {
       copy.role = null;
     }
     if (this.isSetArcrole()) {
       String sourceArcrole;
       sourceArcrole = this.getArcrole();
       String copyArcrole =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "arcrole", sourceArcrole), sourceArcrole));
       copy.setArcrole(copyArcrole);
     } else {
       copy.arcrole = null;
     }
     if (this.isSetTitle()) {
       String sourceTitle;
       sourceTitle = this.getTitle();
       String copyTitle =
           ((String)
               strategy.copy(LocatorUtils.property(locator, "title", sourceTitle), sourceTitle));
       copy.setTitle(copyTitle);
     } else {
       copy.title = null;
     }
     if (this.isSetShow()) {
       String sourceShow;
       sourceShow = this.getShow();
       String copyShow =
           ((String)
               strategy.copy(LocatorUtils.property(locator, "show", sourceShow), sourceShow));
       copy.setShow(copyShow);
     } else {
       copy.show = null;
     }
     if (this.isSetActuate()) {
       String sourceActuate;
       sourceActuate = this.getActuate();
       String copyActuate =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "actuate", sourceActuate), sourceActuate));
       copy.setActuate(copyActuate);
     } else {
       copy.actuate = null;
     }
   }
   return draftCopy;
 }
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof DynamicFeatureMemberType) {
     final DynamicFeatureMemberType copy = ((DynamicFeatureMemberType) draftCopy);
     if (this.isSetDynamicFeature()) {
       List<JAXBElement<? extends DynamicFeatureType>> sourceDynamicFeature;
       sourceDynamicFeature = this.getDynamicFeature();
       @SuppressWarnings("unchecked")
       List<JAXBElement<? extends DynamicFeatureType>> copyDynamicFeature =
           ((List<JAXBElement<? extends DynamicFeatureType>>)
               strategy.copy(
                   LocatorUtils.property(locator, "dynamicFeature", sourceDynamicFeature),
                   sourceDynamicFeature));
       copy.unsetDynamicFeature();
       List<JAXBElement<? extends DynamicFeatureType>> uniqueDynamicFeaturel =
           copy.getDynamicFeature();
       uniqueDynamicFeaturel.addAll(copyDynamicFeature);
     } else {
       copy.unsetDynamicFeature();
     }
     if (this.isSetNilReason()) {
       List<String> sourceNilReason;
       sourceNilReason = this.getNilReason();
       @SuppressWarnings("unchecked")
       List<String> copyNilReason =
           ((List<String>)
               strategy.copy(
                   LocatorUtils.property(locator, "nilReason", sourceNilReason), sourceNilReason));
       copy.unsetNilReason();
       List<String> uniqueNilReasonl = copy.getNilReason();
       uniqueNilReasonl.addAll(copyNilReason);
     } else {
       copy.unsetNilReason();
     }
     if (this.isSetRemoteSchema()) {
       String sourceRemoteSchema;
       sourceRemoteSchema = this.getRemoteSchema();
       String copyRemoteSchema =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "remoteSchema", sourceRemoteSchema),
                   sourceRemoteSchema));
       copy.setRemoteSchema(copyRemoteSchema);
     } else {
       copy.remoteSchema = null;
     }
     if (this.isSetHref()) {
       String sourceHref;
       sourceHref = this.getHref();
       String copyHref =
           ((String)
               strategy.copy(LocatorUtils.property(locator, "href", sourceHref), sourceHref));
       copy.setHref(copyHref);
     } else {
       copy.href = null;
     }
     if (this.isSetRole()) {
       String sourceRole;
       sourceRole = this.getRole();
       String copyRole =
           ((String)
               strategy.copy(LocatorUtils.property(locator, "role", sourceRole), sourceRole));
       copy.setRole(copyRole);
     } else {
       copy.role = null;
     }
     if (this.isSetArcrole()) {
       String sourceArcrole;
       sourceArcrole = this.getArcrole();
       String copyArcrole =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "arcrole", sourceArcrole), sourceArcrole));
       copy.setArcrole(copyArcrole);
     } else {
       copy.arcrole = null;
     }
     if (this.isSetTitle()) {
       String sourceTitle;
       sourceTitle = this.getTitle();
       String copyTitle =
           ((String)
               strategy.copy(LocatorUtils.property(locator, "title", sourceTitle), sourceTitle));
       copy.setTitle(copyTitle);
     } else {
       copy.title = null;
     }
     if (this.isSetShow()) {
       String sourceShow;
       sourceShow = this.getShow();
       String copyShow =
           ((String)
               strategy.copy(LocatorUtils.property(locator, "show", sourceShow), sourceShow));
       copy.setShow(copyShow);
     } else {
       copy.show = null;
     }
     if (this.isSetActuate()) {
       String sourceActuate;
       sourceActuate = this.getActuate();
       String copyActuate =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "actuate", sourceActuate), sourceActuate));
       copy.setActuate(copyActuate);
     } else {
       copy.actuate = null;
     }
   }
   return draftCopy;
 }
Esempio n. 21
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   if (draftCopy instanceof SecureSocketSettings) {
     final SecureSocketSettings copy = ((SecureSocketSettings) draftCopy);
     if (this.mode != null) {
       SecureSocketModeEnum sourceMode;
       sourceMode = this.getMode();
       SecureSocketModeEnum copyMode =
           ((SecureSocketModeEnum)
               strategy.copy(LocatorUtils.property(locator, "mode", sourceMode), sourceMode));
       copy.setMode(copyMode);
     } else {
       copy.mode = null;
     }
     if (this.protocol != null) {
       String sourceProtocol;
       sourceProtocol = this.getProtocol();
       String copyProtocol =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "protocol", sourceProtocol), sourceProtocol));
       copy.setProtocol(copyProtocol);
     } else {
       copy.protocol = null;
     }
     if (this.certificateAuthorityFile != null) {
       String sourceCertificateAuthorityFile;
       sourceCertificateAuthorityFile = this.getCertificateAuthorityFile();
       String copyCertificateAuthorityFile =
           ((String)
               strategy.copy(
                   LocatorUtils.property(
                       locator, "certificateAuthorityFile", sourceCertificateAuthorityFile),
                   sourceCertificateAuthorityFile));
       copy.setCertificateAuthorityFile(copyCertificateAuthorityFile);
     } else {
       copy.certificateAuthorityFile = null;
     }
     if (this.clientCertificateFile != null) {
       String sourceClientCertificateFile;
       sourceClientCertificateFile = this.getClientCertificateFile();
       String copyClientCertificateFile =
           ((String)
               strategy.copy(
                   LocatorUtils.property(
                       locator, "clientCertificateFile", sourceClientCertificateFile),
                   sourceClientCertificateFile));
       copy.setClientCertificateFile(copyClientCertificateFile);
     } else {
       copy.clientCertificateFile = null;
     }
     if (this.clientKeyFile != null) {
       String sourceClientKeyFile;
       sourceClientKeyFile = this.getClientKeyFile();
       String copyClientKeyFile =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "clientKeyFile", sourceClientKeyFile),
                   sourceClientKeyFile));
       copy.setClientKeyFile(copyClientKeyFile);
     } else {
       copy.clientKeyFile = null;
     }
     if (this.clientKeyPassword != null) {
       String sourceClientKeyPassword;
       sourceClientKeyPassword = this.getClientKeyPassword();
       String copyClientKeyPassword =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "clientKeyPassword", sourceClientKeyPassword),
                   sourceClientKeyPassword));
       copy.setClientKeyPassword(copyClientKeyPassword);
     } else {
       copy.clientKeyPassword = null;
     }
     if (this.clientKeyPEM != null) {
       Boolean sourceClientKeyPEM;
       sourceClientKeyPEM = this.isClientKeyPEM();
       Boolean copyClientKeyPEM =
           ((Boolean)
               strategy.copy(
                   LocatorUtils.property(locator, "clientKeyPEM", sourceClientKeyPEM),
                   sourceClientKeyPEM));
       copy.setClientKeyPEM(copyClientKeyPEM);
     } else {
       copy.clientKeyPEM = null;
     }
     if (this.serverKeyStoreFile != null) {
       String sourceServerKeyStoreFile;
       sourceServerKeyStoreFile = this.getServerKeyStoreFile();
       String copyServerKeyStoreFile =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "serverKeyStoreFile", sourceServerKeyStoreFile),
                   sourceServerKeyStoreFile));
       copy.setServerKeyStoreFile(copyServerKeyStoreFile);
     } else {
       copy.serverKeyStoreFile = null;
     }
     if (this.serverKeyStorePassword != null) {
       String sourceServerKeyStorePassword;
       sourceServerKeyStorePassword = this.getServerKeyStorePassword();
       String copyServerKeyStorePassword =
           ((String)
               strategy.copy(
                   LocatorUtils.property(
                       locator, "serverKeyStorePassword", sourceServerKeyStorePassword),
                   sourceServerKeyStorePassword));
       copy.setServerKeyStorePassword(copyServerKeyStorePassword);
     } else {
       copy.serverKeyStorePassword = null;
     }
     if (this.clientKeyStoreFile != null) {
       String sourceClientKeyStoreFile;
       sourceClientKeyStoreFile = this.getClientKeyStoreFile();
       String copyClientKeyStoreFile =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "clientKeyStoreFile", sourceClientKeyStoreFile),
                   sourceClientKeyStoreFile));
       copy.setClientKeyStoreFile(copyClientKeyStoreFile);
     } else {
       copy.clientKeyStoreFile = null;
     }
     if (this.clientKeyStorePassword != null) {
       String sourceClientKeyStorePassword;
       sourceClientKeyStorePassword = this.getClientKeyStorePassword();
       String copyClientKeyStorePassword =
           ((String)
               strategy.copy(
                   LocatorUtils.property(
                       locator, "clientKeyStorePassword", sourceClientKeyStorePassword),
                   sourceClientKeyStorePassword));
       copy.setClientKeyStorePassword(copyClientKeyStorePassword);
     } else {
       copy.clientKeyStorePassword = null;
     }
     if ((this.property != null) && (!this.property.isEmpty())) {
       List<Property> sourceProperty;
       sourceProperty =
           (((this.property != null) && (!this.property.isEmpty())) ? this.getProperty() : null);
       @SuppressWarnings("unchecked")
       List<Property> copyProperty =
           ((List<Property>)
               strategy.copy(
                   LocatorUtils.property(locator, "property", sourceProperty), sourceProperty));
       copy.property = null;
       if (copyProperty != null) {
         List<Property> uniquePropertyl = copy.getProperty();
         uniquePropertyl.addAll(copyProperty);
       }
     } else {
       copy.property = null;
     }
   }
   return draftCopy;
 }
Esempio n. 22
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof MqttConnectionDetails) {
     final MqttConnectionDetails copy = ((MqttConnectionDetails) draftCopy);
     if ((this.serverURI != null) && (!this.serverURI.isEmpty())) {
       List<String> sourceServerURI;
       sourceServerURI =
           (((this.serverURI != null) && (!this.serverURI.isEmpty()))
               ? this.getServerURI()
               : null);
       @SuppressWarnings("unchecked")
       List<String> copyServerURI =
           ((List<String>)
               strategy.copy(
                   LocatorUtils.property(locator, "serverURI", sourceServerURI), sourceServerURI));
       copy.serverURI = null;
       if (copyServerURI != null) {
         List<String> uniqueServerURIl = copy.getServerURI();
         uniqueServerURIl.addAll(copyServerURI);
       }
     } else {
       copy.serverURI = null;
     }
     if (this.webSocket != null) {
       Boolean sourceWebSocket;
       sourceWebSocket = this.isWebSocket();
       Boolean copyWebSocket =
           ((Boolean)
               strategy.copy(
                   LocatorUtils.property(locator, "webSocket", sourceWebSocket), sourceWebSocket));
       copy.setWebSocket(copyWebSocket);
     } else {
       copy.webSocket = null;
     }
     if (this.clientID != null) {
       String sourceClientID;
       sourceClientID = this.getClientID();
       String copyClientID =
           ((String)
               strategy.copy(
                   LocatorUtils.property(locator, "clientID", sourceClientID), sourceClientID));
       copy.setClientID(copyClientID);
     } else {
       copy.clientID = null;
     }
     if (this.userCredentials != null) {
       UserCredentials sourceUserCredentials;
       sourceUserCredentials = this.getUserCredentials();
       UserCredentials copyUserCredentials =
           ((UserCredentials)
               strategy.copy(
                   LocatorUtils.property(locator, "userCredentials", sourceUserCredentials),
                   sourceUserCredentials));
       copy.setUserCredentials(copyUserCredentials);
     } else {
       copy.userCredentials = null;
     }
     if (this.lastWillAndTestament != null) {
       SimpleMqttMessage sourceLastWillAndTestament;
       sourceLastWillAndTestament = this.getLastWillAndTestament();
       SimpleMqttMessage copyLastWillAndTestament =
           ((SimpleMqttMessage)
               strategy.copy(
                   LocatorUtils.property(
                       locator, "lastWillAndTestament", sourceLastWillAndTestament),
                   sourceLastWillAndTestament));
       copy.setLastWillAndTestament(copyLastWillAndTestament);
     } else {
       copy.lastWillAndTestament = null;
     }
     if (this.cleanSession != null) {
       Boolean sourceCleanSession;
       sourceCleanSession = this.isCleanSession();
       Boolean copyCleanSession =
           ((Boolean)
               strategy.copy(
                   LocatorUtils.property(locator, "cleanSession", sourceCleanSession),
                   sourceCleanSession));
       copy.setCleanSession(copyCleanSession);
     } else {
       copy.cleanSession = null;
     }
     if (this.connectionTimeout != null) {
       Integer sourceConnectionTimeout;
       sourceConnectionTimeout = this.getConnectionTimeout();
       Integer copyConnectionTimeout =
           ((Integer)
               strategy.copy(
                   LocatorUtils.property(locator, "connectionTimeout", sourceConnectionTimeout),
                   sourceConnectionTimeout));
       copy.setConnectionTimeout(copyConnectionTimeout);
     } else {
       copy.connectionTimeout = null;
     }
     if (this.keepAliveInterval != null) {
       Integer sourceKeepAliveInterval;
       sourceKeepAliveInterval = this.getKeepAliveInterval();
       Integer copyKeepAliveInterval =
           ((Integer)
               strategy.copy(
                   LocatorUtils.property(locator, "keepAliveInterval", sourceKeepAliveInterval),
                   sourceKeepAliveInterval));
       copy.setKeepAliveInterval(copyKeepAliveInterval);
     } else {
       copy.keepAliveInterval = null;
     }
     if (this.ssl != null) {
       SecureSocketSettings sourceSSL;
       sourceSSL = this.getSSL();
       SecureSocketSettings copySSL =
           ((SecureSocketSettings)
               strategy.copy(LocatorUtils.property(locator, "ssl", sourceSSL), sourceSSL));
       copy.setSSL(copySSL);
     } else {
       copy.ssl = null;
     }
     if (this.reconnectionSettings != null) {
       ReconnectionSettings sourceReconnectionSettings;
       sourceReconnectionSettings = this.getReconnectionSettings();
       ReconnectionSettings copyReconnectionSettings =
           ((ReconnectionSettings)
               strategy.copy(
                   LocatorUtils.property(
                       locator, "reconnectionSettings", sourceReconnectionSettings),
                   sourceReconnectionSettings));
       copy.setReconnectionSettings(copyReconnectionSettings);
     } else {
       copy.reconnectionSettings = null;
     }
   }
   return draftCopy;
 }