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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}