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