Пример #1
0
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof TopoSolidType) {
     final TopoSolidType target = this;
     final TopoSolidType leftObject = ((TopoSolidType) left);
     final TopoSolidType rightObject = ((TopoSolidType) right);
     {
       List<DirectedFacePropertyType> lhsDirectedFace;
       lhsDirectedFace = leftObject.getDirectedFace();
       List<DirectedFacePropertyType> rhsDirectedFace;
       rhsDirectedFace = rightObject.getDirectedFace();
       target.unsetDirectedFace();
       List<DirectedFacePropertyType> uniqueDirectedFacel = target.getDirectedFace();
       uniqueDirectedFacel.addAll(
           ((List<DirectedFacePropertyType>)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "directedFace", lhsDirectedFace),
                   LocatorUtils.property(rightLocator, "directedFace", rhsDirectedFace),
                   lhsDirectedFace,
                   rhsDirectedFace)));
     }
     {
       SolidPropertyType lhsSolidProperty;
       lhsSolidProperty = leftObject.getSolidProperty();
       SolidPropertyType rhsSolidProperty;
       rhsSolidProperty = rightObject.getSolidProperty();
       target.setSolidProperty(
           ((SolidPropertyType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "solidProperty", lhsSolidProperty),
                   LocatorUtils.property(rightLocator, "solidProperty", rhsSolidProperty),
                   lhsSolidProperty,
                   rhsSolidProperty)));
     }
     {
       AggregationType lhsAggregationType;
       lhsAggregationType = leftObject.getAggregationType();
       AggregationType rhsAggregationType;
       rhsAggregationType = rightObject.getAggregationType();
       target.setAggregationType(
           ((AggregationType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "aggregationType", lhsAggregationType),
                   LocatorUtils.property(rightLocator, "aggregationType", rhsAggregationType),
                   lhsAggregationType,
                   rhsAggregationType)));
     }
   }
 }
Пример #2
0
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof SurfaceType) {
     final SurfaceType target = this;
     final SurfaceType leftObject = ((SurfaceType) left);
     final SurfaceType rightObject = ((SurfaceType) right);
     {
       JAXBElement<? extends SurfacePatchArrayPropertyType> lhsPatches;
       lhsPatches = leftObject.getPatches();
       JAXBElement<? extends SurfacePatchArrayPropertyType> rhsPatches;
       rhsPatches = rightObject.getPatches();
       target.setPatches(
           ((JAXBElement<? extends SurfacePatchArrayPropertyType>)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "patches", lhsPatches),
                   LocatorUtils.property(rightLocator, "patches", rhsPatches),
                   lhsPatches,
                   rhsPatches)));
     }
   }
 }
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof AbstractTimePrimitiveType) {
     final AbstractTimePrimitiveType target = this;
     final AbstractTimePrimitiveType leftObject = ((AbstractTimePrimitiveType) left);
     final AbstractTimePrimitiveType rightObject = ((AbstractTimePrimitiveType) right);
     {
       List<RelatedTimeType> lhsRelatedTime;
       lhsRelatedTime = leftObject.getRelatedTime();
       List<RelatedTimeType> rhsRelatedTime;
       rhsRelatedTime = rightObject.getRelatedTime();
       target.unsetRelatedTime();
       List<RelatedTimeType> uniqueRelatedTimel = target.getRelatedTime();
       uniqueRelatedTimel.addAll(
           ((List<RelatedTimeType>)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "relatedTime", lhsRelatedTime),
                   LocatorUtils.property(rightLocator, "relatedTime", rhsRelatedTime),
                   lhsRelatedTime,
                   rhsRelatedTime)));
     }
   }
 }
Пример #4
0
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof RectangleType) {
     final RectangleType target = this;
     final RectangleType leftObject = ((RectangleType) left);
     final RectangleType rightObject = ((RectangleType) right);
     {
       AbstractRingPropertyType lhsExterior;
       lhsExterior = leftObject.getExterior();
       AbstractRingPropertyType rhsExterior;
       rhsExterior = rightObject.getExterior();
       target.setExterior(
           ((AbstractRingPropertyType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "exterior", lhsExterior),
                   LocatorUtils.property(rightLocator, "exterior", rhsExterior),
                   lhsExterior,
                   rhsExterior)));
     }
   }
 }
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   if (right instanceof IndirectEntryType) {
     final IndirectEntryType target = this;
     final IndirectEntryType leftObject = ((IndirectEntryType) left);
     final IndirectEntryType rightObject = ((IndirectEntryType) right);
     {
       DefinitionProxyType lhsDefinitionProxy;
       lhsDefinitionProxy = leftObject.getDefinitionProxy();
       DefinitionProxyType rhsDefinitionProxy;
       rhsDefinitionProxy = rightObject.getDefinitionProxy();
       target.setDefinitionProxy(
           ((DefinitionProxyType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "definitionProxy", lhsDefinitionProxy),
                   LocatorUtils.property(rightLocator, "definitionProxy", rhsDefinitionProxy),
                   lhsDefinitionProxy,
                   rhsDefinitionProxy)));
     }
   }
 }
Пример #6
0
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof RelatedTimeType) {
     final RelatedTimeType target = this;
     final RelatedTimeType leftObject = ((RelatedTimeType) left);
     final RelatedTimeType rightObject = ((RelatedTimeType) right);
     {
       String lhsRelativePosition;
       lhsRelativePosition = leftObject.getRelativePosition();
       String rhsRelativePosition;
       rhsRelativePosition = rightObject.getRelativePosition();
       target.setRelativePosition(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "relativePosition", lhsRelativePosition),
                   LocatorUtils.property(rightLocator, "relativePosition", rhsRelativePosition),
                   lhsRelativePosition,
                   rhsRelativePosition)));
     }
   }
 }
Пример #7
0
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof DefinitionType) {
     final DefinitionType target = this;
     final DefinitionType leftObject = ((DefinitionType) left);
     final DefinitionType rightObject = ((DefinitionType) right);
     {
       String lhsRemarks;
       lhsRemarks = leftObject.getRemarks();
       String rhsRemarks;
       rhsRemarks = rightObject.getRemarks();
       target.setRemarks(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "remarks", lhsRemarks),
                   LocatorUtils.property(rightLocator, "remarks", rhsRemarks),
                   lhsRemarks,
                   rhsRemarks)));
     }
   }
 }
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof CompositeSurfaceType) {
     final CompositeSurfaceType target = this;
     final CompositeSurfaceType leftObject = ((CompositeSurfaceType) left);
     final CompositeSurfaceType rightObject = ((CompositeSurfaceType) right);
     {
       List<SurfacePropertyType> lhsSurfaceMember;
       lhsSurfaceMember = leftObject.getSurfaceMember();
       List<SurfacePropertyType> rhsSurfaceMember;
       rhsSurfaceMember = rightObject.getSurfaceMember();
       target.unsetSurfaceMember();
       List<SurfacePropertyType> uniqueSurfaceMemberl = target.getSurfaceMember();
       uniqueSurfaceMemberl.addAll(
           ((List<SurfacePropertyType>)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "surfaceMember", lhsSurfaceMember),
                   LocatorUtils.property(rightLocator, "surfaceMember", rhsSurfaceMember),
                   lhsSurfaceMember,
                   rhsSurfaceMember)));
     }
     {
       AggregationType lhsAggregationType;
       lhsAggregationType = leftObject.getAggregationType();
       AggregationType rhsAggregationType;
       rhsAggregationType = rightObject.getAggregationType();
       target.setAggregationType(
           ((AggregationType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "aggregationType", lhsAggregationType),
                   LocatorUtils.property(rightLocator, "aggregationType", rhsAggregationType),
                   lhsAggregationType,
                   rhsAggregationType)));
     }
   }
 }
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof AbstractCoverageType) {
     final AbstractCoverageType target = this;
     final AbstractCoverageType leftObject = ((AbstractCoverageType) left);
     final AbstractCoverageType rightObject = ((AbstractCoverageType) right);
     {
       JAXBElement<? extends DomainSetType> lhsDomainSet;
       lhsDomainSet = leftObject.getDomainSet();
       JAXBElement<? extends DomainSetType> rhsDomainSet;
       rhsDomainSet = rightObject.getDomainSet();
       target.setDomainSet(
           ((JAXBElement<? extends DomainSetType>)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "domainSet", lhsDomainSet),
                   LocatorUtils.property(rightLocator, "domainSet", rhsDomainSet),
                   lhsDomainSet,
                   rhsDomainSet)));
     }
     {
       RangeSetType lhsRangeSet;
       lhsRangeSet = leftObject.getRangeSet();
       RangeSetType rhsRangeSet;
       rhsRangeSet = rightObject.getRangeSet();
       target.setRangeSet(
           ((RangeSetType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "rangeSet", lhsRangeSet),
                   LocatorUtils.property(rightLocator, "rangeSet", rhsRangeSet),
                   lhsRangeSet,
                   rhsRangeSet)));
     }
   }
 }
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   if (right instanceof TopoCurvePropertyType) {
     final TopoCurvePropertyType target = this;
     final TopoCurvePropertyType leftObject = ((TopoCurvePropertyType) left);
     final TopoCurvePropertyType rightObject = ((TopoCurvePropertyType) right);
     {
       TopoCurveType lhsTopoCurve;
       lhsTopoCurve = leftObject.getTopoCurve();
       TopoCurveType rhsTopoCurve;
       rhsTopoCurve = rightObject.getTopoCurve();
       target.setTopoCurve(
           ((TopoCurveType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "topoCurve", lhsTopoCurve),
                   LocatorUtils.property(rightLocator, "topoCurve", rhsTopoCurve),
                   lhsTopoCurve,
                   rhsTopoCurve)));
     }
     {
       boolean lhsOwns;
       lhsOwns = leftObject.isOwns();
       boolean rhsOwns;
       rhsOwns = rightObject.isOwns();
       target.setOwns(
           ((boolean)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "owns", lhsOwns),
                   LocatorUtils.property(rightLocator, "owns", rhsOwns),
                   lhsOwns,
                   rhsOwns)));
     }
   }
 }
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof AbstractCoordinateOperationType) {
     final AbstractCoordinateOperationType target = this;
     final AbstractCoordinateOperationType leftObject = ((AbstractCoordinateOperationType) left);
     final AbstractCoordinateOperationType rightObject = ((AbstractCoordinateOperationType) right);
     {
       DomainOfValidityElement lhsDomainOfValidity;
       lhsDomainOfValidity = leftObject.getDomainOfValidity();
       DomainOfValidityElement rhsDomainOfValidity;
       rhsDomainOfValidity = rightObject.getDomainOfValidity();
       target.setDomainOfValidity(
           ((DomainOfValidityElement)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "domainOfValidity", lhsDomainOfValidity),
                   LocatorUtils.property(rightLocator, "domainOfValidity", rhsDomainOfValidity),
                   lhsDomainOfValidity,
                   rhsDomainOfValidity)));
     }
     {
       List<String> lhsScope;
       lhsScope = leftObject.getScope();
       List<String> rhsScope;
       rhsScope = rightObject.getScope();
       target.unsetScope();
       List<String> uniqueScopel = target.getScope();
       uniqueScopel.addAll(
           ((List<String>)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "scope", lhsScope),
                   LocatorUtils.property(rightLocator, "scope", rhsScope),
                   lhsScope,
                   rhsScope)));
     }
     {
       String lhsOperationVersion;
       lhsOperationVersion = leftObject.getOperationVersion();
       String rhsOperationVersion;
       rhsOperationVersion = rightObject.getOperationVersion();
       target.setOperationVersion(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "operationVersion", lhsOperationVersion),
                   LocatorUtils.property(rightLocator, "operationVersion", rhsOperationVersion),
                   lhsOperationVersion,
                   rhsOperationVersion)));
     }
     {
       List<CoordinateOperationAccuracyElement> lhsCoordinateOperationAccuracy;
       lhsCoordinateOperationAccuracy = leftObject.getCoordinateOperationAccuracy();
       List<CoordinateOperationAccuracyElement> rhsCoordinateOperationAccuracy;
       rhsCoordinateOperationAccuracy = rightObject.getCoordinateOperationAccuracy();
       target.unsetCoordinateOperationAccuracy();
       List<CoordinateOperationAccuracyElement> uniqueCoordinateOperationAccuracyl =
           target.getCoordinateOperationAccuracy();
       uniqueCoordinateOperationAccuracyl.addAll(
           ((List<CoordinateOperationAccuracyElement>)
               strategy.merge(
                   LocatorUtils.property(
                       leftLocator, "coordinateOperationAccuracy", lhsCoordinateOperationAccuracy),
                   LocatorUtils.property(
                       rightLocator,
                       "coordinateOperationAccuracy",
                       rhsCoordinateOperationAccuracy),
                   lhsCoordinateOperationAccuracy,
                   rhsCoordinateOperationAccuracy)));
     }
     {
       CRSPropertyType lhsSourceCRS;
       lhsSourceCRS = leftObject.getSourceCRS();
       CRSPropertyType rhsSourceCRS;
       rhsSourceCRS = rightObject.getSourceCRS();
       target.setSourceCRS(
           ((CRSPropertyType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "sourceCRS", lhsSourceCRS),
                   LocatorUtils.property(rightLocator, "sourceCRS", rhsSourceCRS),
                   lhsSourceCRS,
                   rhsSourceCRS)));
     }
     {
       CRSPropertyType lhsTargetCRS;
       lhsTargetCRS = leftObject.getTargetCRS();
       CRSPropertyType rhsTargetCRS;
       rhsTargetCRS = rightObject.getTargetCRS();
       target.setTargetCRS(
           ((CRSPropertyType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "targetCRS", lhsTargetCRS),
                   LocatorUtils.property(rightLocator, "targetCRS", rhsTargetCRS),
                   lhsTargetCRS,
                   rhsTargetCRS)));
     }
   }
 }
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   if (right instanceof TimeCalendarEraPropertyType) {
     final TimeCalendarEraPropertyType target = this;
     final TimeCalendarEraPropertyType leftObject = ((TimeCalendarEraPropertyType) left);
     final TimeCalendarEraPropertyType rightObject = ((TimeCalendarEraPropertyType) right);
     {
       TimeCalendarEraType lhsTimeCalendarEra;
       lhsTimeCalendarEra = leftObject.getTimeCalendarEra();
       TimeCalendarEraType rhsTimeCalendarEra;
       rhsTimeCalendarEra = rightObject.getTimeCalendarEra();
       target.setTimeCalendarEra(
           ((TimeCalendarEraType)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "timeCalendarEra", lhsTimeCalendarEra),
                   LocatorUtils.property(rightLocator, "timeCalendarEra", rhsTimeCalendarEra),
                   lhsTimeCalendarEra,
                   rhsTimeCalendarEra)));
     }
     {
       boolean lhsOwns;
       lhsOwns = leftObject.isOwns();
       boolean rhsOwns;
       rhsOwns = rightObject.isOwns();
       target.setOwns(
           ((boolean)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "owns", lhsOwns),
                   LocatorUtils.property(rightLocator, "owns", rhsOwns),
                   lhsOwns,
                   rhsOwns)));
     }
     {
       List<String> lhsNilReason;
       lhsNilReason = leftObject.getNilReason();
       List<String> rhsNilReason;
       rhsNilReason = rightObject.getNilReason();
       target.unsetNilReason();
       List<String> uniqueNilReasonl = target.getNilReason();
       uniqueNilReasonl.addAll(
           ((List<String>)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "nilReason", lhsNilReason),
                   LocatorUtils.property(rightLocator, "nilReason", rhsNilReason),
                   lhsNilReason,
                   rhsNilReason)));
     }
     {
       String lhsRemoteSchema;
       lhsRemoteSchema = leftObject.getRemoteSchema();
       String rhsRemoteSchema;
       rhsRemoteSchema = rightObject.getRemoteSchema();
       target.setRemoteSchema(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "remoteSchema", lhsRemoteSchema),
                   LocatorUtils.property(rightLocator, "remoteSchema", rhsRemoteSchema),
                   lhsRemoteSchema,
                   rhsRemoteSchema)));
     }
     {
       String lhsHref;
       lhsHref = leftObject.getHref();
       String rhsHref;
       rhsHref = rightObject.getHref();
       target.setHref(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "href", lhsHref),
                   LocatorUtils.property(rightLocator, "href", rhsHref),
                   lhsHref,
                   rhsHref)));
     }
     {
       String lhsRole;
       lhsRole = leftObject.getRole();
       String rhsRole;
       rhsRole = rightObject.getRole();
       target.setRole(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "role", lhsRole),
                   LocatorUtils.property(rightLocator, "role", rhsRole),
                   lhsRole,
                   rhsRole)));
     }
     {
       String lhsArcrole;
       lhsArcrole = leftObject.getArcrole();
       String rhsArcrole;
       rhsArcrole = rightObject.getArcrole();
       target.setArcrole(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "arcrole", lhsArcrole),
                   LocatorUtils.property(rightLocator, "arcrole", rhsArcrole),
                   lhsArcrole,
                   rhsArcrole)));
     }
     {
       String lhsTitle;
       lhsTitle = leftObject.getTitle();
       String rhsTitle;
       rhsTitle = rightObject.getTitle();
       target.setTitle(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "title", lhsTitle),
                   LocatorUtils.property(rightLocator, "title", rhsTitle),
                   lhsTitle,
                   rhsTitle)));
     }
     {
       String lhsShow;
       lhsShow = leftObject.getShow();
       String rhsShow;
       rhsShow = rightObject.getShow();
       target.setShow(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "show", lhsShow),
                   LocatorUtils.property(rightLocator, "show", rhsShow),
                   lhsShow,
                   rhsShow)));
     }
     {
       String lhsActuate;
       lhsActuate = leftObject.getActuate();
       String rhsActuate;
       rhsActuate = rightObject.getActuate();
       target.setActuate(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "actuate", lhsActuate),
                   LocatorUtils.property(rightLocator, "actuate", rhsActuate),
                   lhsActuate,
                   rhsActuate)));
     }
   }
 }
 public void mergeFrom(
     ObjectLocator leftLocator,
     ObjectLocator rightLocator,
     Object left,
     Object right,
     MergeStrategy strategy) {
   super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
   if (right instanceof DynamicFeatureMemberType) {
     final DynamicFeatureMemberType target = this;
     final DynamicFeatureMemberType leftObject = ((DynamicFeatureMemberType) left);
     final DynamicFeatureMemberType rightObject = ((DynamicFeatureMemberType) right);
     {
       List<JAXBElement<? extends DynamicFeatureType>> lhsDynamicFeature;
       lhsDynamicFeature = leftObject.getDynamicFeature();
       List<JAXBElement<? extends DynamicFeatureType>> rhsDynamicFeature;
       rhsDynamicFeature = rightObject.getDynamicFeature();
       target.unsetDynamicFeature();
       List<JAXBElement<? extends DynamicFeatureType>> uniqueDynamicFeaturel =
           target.getDynamicFeature();
       uniqueDynamicFeaturel.addAll(
           ((List<JAXBElement<? extends DynamicFeatureType>>)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "dynamicFeature", lhsDynamicFeature),
                   LocatorUtils.property(rightLocator, "dynamicFeature", rhsDynamicFeature),
                   lhsDynamicFeature,
                   rhsDynamicFeature)));
     }
     {
       List<String> lhsNilReason;
       lhsNilReason = leftObject.getNilReason();
       List<String> rhsNilReason;
       rhsNilReason = rightObject.getNilReason();
       target.unsetNilReason();
       List<String> uniqueNilReasonl = target.getNilReason();
       uniqueNilReasonl.addAll(
           ((List<String>)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "nilReason", lhsNilReason),
                   LocatorUtils.property(rightLocator, "nilReason", rhsNilReason),
                   lhsNilReason,
                   rhsNilReason)));
     }
     {
       String lhsRemoteSchema;
       lhsRemoteSchema = leftObject.getRemoteSchema();
       String rhsRemoteSchema;
       rhsRemoteSchema = rightObject.getRemoteSchema();
       target.setRemoteSchema(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "remoteSchema", lhsRemoteSchema),
                   LocatorUtils.property(rightLocator, "remoteSchema", rhsRemoteSchema),
                   lhsRemoteSchema,
                   rhsRemoteSchema)));
     }
     {
       String lhsHref;
       lhsHref = leftObject.getHref();
       String rhsHref;
       rhsHref = rightObject.getHref();
       target.setHref(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "href", lhsHref),
                   LocatorUtils.property(rightLocator, "href", rhsHref),
                   lhsHref,
                   rhsHref)));
     }
     {
       String lhsRole;
       lhsRole = leftObject.getRole();
       String rhsRole;
       rhsRole = rightObject.getRole();
       target.setRole(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "role", lhsRole),
                   LocatorUtils.property(rightLocator, "role", rhsRole),
                   lhsRole,
                   rhsRole)));
     }
     {
       String lhsArcrole;
       lhsArcrole = leftObject.getArcrole();
       String rhsArcrole;
       rhsArcrole = rightObject.getArcrole();
       target.setArcrole(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "arcrole", lhsArcrole),
                   LocatorUtils.property(rightLocator, "arcrole", rhsArcrole),
                   lhsArcrole,
                   rhsArcrole)));
     }
     {
       String lhsTitle;
       lhsTitle = leftObject.getTitle();
       String rhsTitle;
       rhsTitle = rightObject.getTitle();
       target.setTitle(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "title", lhsTitle),
                   LocatorUtils.property(rightLocator, "title", rhsTitle),
                   lhsTitle,
                   rhsTitle)));
     }
     {
       String lhsShow;
       lhsShow = leftObject.getShow();
       String rhsShow;
       rhsShow = rightObject.getShow();
       target.setShow(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "show", lhsShow),
                   LocatorUtils.property(rightLocator, "show", rhsShow),
                   lhsShow,
                   rhsShow)));
     }
     {
       String lhsActuate;
       lhsActuate = leftObject.getActuate();
       String rhsActuate;
       rhsActuate = rightObject.getActuate();
       target.setActuate(
           ((String)
               strategy.merge(
                   LocatorUtils.property(leftLocator, "actuate", lhsActuate),
                   LocatorUtils.property(rightLocator, "actuate", rhsActuate),
                   lhsActuate,
                   rhsActuate)));
     }
   }
 }