public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) {
int currentHashCode = super.hashCode(locator, strategy);
{
List<DirectedFacePropertyType> theDirectedFace;
theDirectedFace = this.getDirectedFace();
currentHashCode =
strategy.hashCode(
LocatorUtils.property(locator, "directedFace", theDirectedFace),
currentHashCode,
theDirectedFace);
}
{
SolidPropertyType theSolidProperty;
theSolidProperty = this.getSolidProperty();
currentHashCode =
strategy.hashCode(
LocatorUtils.property(locator, "solidProperty", theSolidProperty),
currentHashCode,
theSolidProperty);
}
{
AggregationType theAggregationType;
theAggregationType = this.getAggregationType();
currentHashCode =
strategy.hashCode(
LocatorUtils.property(locator, "aggregationType", theAggregationType),
currentHashCode,
theAggregationType);
}
return currentHashCode;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof AuthenticationProfiles)) {
return false;
}
if (this == object) {
return true;
}
final AuthenticationProfiles that = ((AuthenticationProfiles) object);
{
List<QName> lhsProfile;
lhsProfile =
(((this.profile != null) && (!this.profile.isEmpty())) ? this.getProfile() : null);
List<QName> rhsProfile;
rhsProfile =
(((that.profile != null) && (!that.profile.isEmpty())) ? that.getProfile() : null);
if (!strategy.equals(
LocatorUtils.property(thisLocator, "profile", lhsProfile),
LocatorUtils.property(thatLocator, "profile", rhsProfile),
lhsProfile,
rhsProfile)) {
return false;
}
}
return true;
}
public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) {
int currentHashCode = 1;
{
Empty theDOUTSIDESCOPE;
theDOUTSIDESCOPE = this.getDOUTSIDESCOPE();
currentHashCode =
strategy.hashCode(
LocatorUtils.property(locator, "doutsidescope", theDOUTSIDESCOPE),
currentHashCode,
theDOUTSIDESCOPE);
}
{
eu.europa.publications.formex.ted.schema.ProcedureF15.DIRECTIVE201424EU
.PTNEGOTIATEDWITHOUTPUBLICATION
.DACCORDANCEARTICLE
theDACCORDANCEARTICLE;
theDACCORDANCEARTICLE = this.getDACCORDANCEARTICLE();
currentHashCode =
strategy.hashCode(
LocatorUtils.property(locator, "daccordancearticle", theDACCORDANCEARTICLE),
currentHashCode,
theDACCORDANCEARTICLE);
}
{
TextFtMultiLines theDJUSTIFICATION;
theDJUSTIFICATION = this.getDJUSTIFICATION();
currentHashCode =
strategy.hashCode(
LocatorUtils.property(locator, "djustification", theDJUSTIFICATION),
currentHashCode,
theDJUSTIFICATION);
}
return currentHashCode;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof Pictures)) {
return false;
}
if (this == object) {
return true;
}
final Pictures that = ((Pictures) object);
{
List<Picture> lhsPicture;
lhsPicture =
(((this.picture != null) && (!this.picture.isEmpty())) ? this.getPicture() : null);
List<Picture> rhsPicture;
rhsPicture =
(((that.picture != null) && (!that.picture.isEmpty())) ? that.getPicture() : null);
if (!strategy.equals(
LocatorUtils.property(thisLocator, "picture", lhsPicture),
LocatorUtils.property(thatLocator, "picture", rhsPicture),
lhsPicture,
rhsPicture)) {
return false;
}
}
return true;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof SurfaceType)) {
return false;
}
if (this == object) {
return true;
}
if (!super.equals(thisLocator, thatLocator, object, strategy)) {
return false;
}
final SurfaceType that = ((SurfaceType) object);
{
JAXBElement<? extends SurfacePatchArrayPropertyType> lhsPatches;
lhsPatches = this.getPatches();
JAXBElement<? extends SurfacePatchArrayPropertyType> rhsPatches;
rhsPatches = that.getPatches();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "patches", lhsPatches),
LocatorUtils.property(thatLocator, "patches", rhsPatches),
lhsPatches,
rhsPatches)) {
return false;
}
}
return true;
}
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 boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof ScriptExecutionDetails)) {
return false;
}
if (this == object) {
return true;
}
final ScriptExecutionDetails that = ((ScriptExecutionDetails) object);
{
String lhsInlineScript;
lhsInlineScript = this.getInlineScript();
String rhsInlineScript;
rhsInlineScript = that.getInlineScript();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "inlineScript", lhsInlineScript),
LocatorUtils.property(thatLocator, "inlineScript", rhsInlineScript),
lhsInlineScript,
rhsInlineScript)) {
return false;
}
}
return true;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof UnitPrice)) {
return false;
}
if (this == object) {
return true;
}
final UnitPrice that = ((UnitPrice) object);
{
FinancialAmount lhsFinancialAmount;
lhsFinancialAmount = this.getFinancialAmount();
FinancialAmount rhsFinancialAmount;
rhsFinancialAmount = that.getFinancialAmount();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "financialAmount", lhsFinancialAmount),
LocatorUtils.property(thatLocator, "financialAmount", rhsFinancialAmount),
lhsFinancialAmount,
rhsFinancialAmount)) {
return false;
}
}
return true;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof FindPermissionsRequest.Filter)) {
return false;
}
if (this == object) {
return true;
}
final FindPermissionsRequest.Filter that = ((FindPermissionsRequest.Filter) object);
{
PermissionFilter lhsPermissionFilter;
lhsPermissionFilter = this.getPermissionFilter();
PermissionFilter rhsPermissionFilter;
rhsPermissionFilter = that.getPermissionFilter();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "permissionFilter", lhsPermissionFilter),
LocatorUtils.property(thatLocator, "permissionFilter", rhsPermissionFilter),
lhsPermissionFilter,
rhsPermissionFilter)) {
return false;
}
}
return true;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof BillTo)) {
return false;
}
if (this == object) {
return true;
}
final BillTo that = ((BillTo) object);
{
PartnerDescription lhsPartnerDescription;
lhsPartnerDescription = this.getPartnerDescription();
PartnerDescription rhsPartnerDescription;
rhsPartnerDescription = that.getPartnerDescription();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "partnerDescription", lhsPartnerDescription),
LocatorUtils.property(thatLocator, "partnerDescription", rhsPartnerDescription),
lhsPartnerDescription,
rhsPartnerDescription)) {
return false;
}
}
return true;
}
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);
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 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 boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof IndirectEntryType)) {
return false;
}
if (this == object) {
return true;
}
final IndirectEntryType that = ((IndirectEntryType) object);
{
DefinitionProxyType lhsDefinitionProxy;
lhsDefinitionProxy = this.getDefinitionProxy();
DefinitionProxyType rhsDefinitionProxy;
rhsDefinitionProxy = that.getDefinitionProxy();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "definitionProxy", lhsDefinitionProxy),
LocatorUtils.property(thatLocator, "definitionProxy", rhsDefinitionProxy),
lhsDefinitionProxy,
rhsDefinitionProxy)) {
return false;
}
}
return true;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof AbstractTimePrimitiveType)) {
return false;
}
if (this == object) {
return true;
}
if (!super.equals(thisLocator, thatLocator, object, strategy)) {
return false;
}
final AbstractTimePrimitiveType that = ((AbstractTimePrimitiveType) object);
{
List<RelatedTimeType> lhsRelatedTime;
lhsRelatedTime = this.getRelatedTime();
List<RelatedTimeType> rhsRelatedTime;
rhsRelatedTime = that.getRelatedTime();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "relatedTime", lhsRelatedTime),
LocatorUtils.property(thatLocator, "relatedTime", rhsRelatedTime),
lhsRelatedTime,
rhsRelatedTime)) {
return false;
}
}
return true;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof SpecialHandlingText)) {
return false;
}
if (this == object) {
return true;
}
final SpecialHandlingText that = ((SpecialHandlingText) object);
{
FreeFormText lhsFreeFormText;
lhsFreeFormText = this.getFreeFormText();
FreeFormText rhsFreeFormText;
rhsFreeFormText = that.getFreeFormText();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "freeFormText", lhsFreeFormText),
LocatorUtils.property(thatLocator, "freeFormText", rhsFreeFormText),
lhsFreeFormText,
rhsFreeFormText)) {
return false;
}
}
return true;
}
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 boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof PostOfficeBoxIdentifier)) {
return false;
}
if (this == object) {
return true;
}
final PostOfficeBoxIdentifier that = ((PostOfficeBoxIdentifier) object);
{
FreeFormText lhsFreeFormText;
lhsFreeFormText = this.getFreeFormText();
FreeFormText rhsFreeFormText;
rhsFreeFormText = that.getFreeFormText();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "freeFormText", lhsFreeFormText),
LocatorUtils.property(thatLocator, "freeFormText", rhsFreeFormText),
lhsFreeFormText,
rhsFreeFormText)) {
return false;
}
}
return true;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof ScheduledShipQuantity)) {
return false;
}
if (this == object) {
return true;
}
final ScheduledShipQuantity that = ((ScheduledShipQuantity) object);
{
String lhsProductQuantity;
lhsProductQuantity = this.getProductQuantity();
String rhsProductQuantity;
rhsProductQuantity = that.getProductQuantity();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "productQuantity", lhsProductQuantity),
LocatorUtils.property(thatLocator, "productQuantity", rhsProductQuantity),
lhsProductQuantity,
rhsProductQuantity)) {
return false;
}
}
return true;
}
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 boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof SecondaryBuyerPurchaseOrderIdentifier)) {
return false;
}
if (this == object) {
return true;
}
final SecondaryBuyerPurchaseOrderIdentifier that =
((SecondaryBuyerPurchaseOrderIdentifier) object);
{
String lhsProprietaryDocumentIdentifier;
lhsProprietaryDocumentIdentifier = this.getProprietaryDocumentIdentifier();
String rhsProprietaryDocumentIdentifier;
rhsProprietaryDocumentIdentifier = that.getProprietaryDocumentIdentifier();
if (!strategy.equals(
LocatorUtils.property(
thisLocator, "proprietaryDocumentIdentifier", lhsProprietaryDocumentIdentifier),
LocatorUtils.property(
thatLocator, "proprietaryDocumentIdentifier", rhsProprietaryDocumentIdentifier),
lhsProprietaryDocumentIdentifier,
rhsProprietaryDocumentIdentifier)) {
return false;
}
}
return true;
}
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 boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof Document)) {
return false;
}
if (this == object) {
return true;
}
final Document that = ((Document) object);
{
List<StatementOrBundle> lhsStatementOrBundle;
lhsStatementOrBundle =
(((this.statementOrBundle != null) && (!this.statementOrBundle.isEmpty()))
? this.getStatementOrBundle()
: null);
List<StatementOrBundle> rhsStatementOrBundle;
rhsStatementOrBundle =
(((that.statementOrBundle != null) && (!that.statementOrBundle.isEmpty()))
? that.getStatementOrBundle()
: null);
if (!strategy.equals(
LocatorUtils.property(thisLocator, "statementOrBundle", lhsStatementOrBundle),
LocatorUtils.property(thatLocator, "statementOrBundle", rhsStatementOrBundle),
lhsStatementOrBundle,
rhsStatementOrBundle)) {
return false;
}
}
return true;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof Music)) {
return false;
}
if (this == object) {
return true;
}
final Music that = ((Music) object);
{
List<File> lhsFile;
lhsFile = (((this.file != null) && (!this.file.isEmpty())) ? this.getFile() : null);
List<File> rhsFile;
rhsFile = (((that.file != null) && (!that.file.isEmpty())) ? that.getFile() : null);
if (!strategy.equals(
LocatorUtils.property(thisLocator, "file", lhsFile),
LocatorUtils.property(thatLocator, "file", rhsFile),
lhsFile,
rhsFile)) {
return false;
}
}
return true;
}
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 boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof RectangleType)) {
return false;
}
if (this == object) {
return true;
}
if (!super.equals(thisLocator, thatLocator, object, strategy)) {
return false;
}
final RectangleType that = ((RectangleType) object);
{
AbstractRingPropertyType lhsExterior;
lhsExterior = this.getExterior();
AbstractRingPropertyType rhsExterior;
rhsExterior = that.getExterior();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "exterior", lhsExterior),
LocatorUtils.property(thatLocator, "exterior", rhsExterior),
lhsExterior,
rhsExterior)) {
return false;
}
}
return true;
}
public boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof ScheduledEvent)) {
return false;
}
if (this == object) {
return true;
}
final ScheduledEvent that = ((ScheduledEvent) object);
{
TransportationEvent lhsTransportationEvent;
lhsTransportationEvent = this.getTransportationEvent();
TransportationEvent rhsTransportationEvent;
rhsTransportationEvent = that.getTransportationEvent();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "transportationEvent", lhsTransportationEvent),
LocatorUtils.property(thatLocator, "transportationEvent", rhsTransportationEvent),
lhsTransportationEvent,
rhsTransportationEvent)) {
return false;
}
}
return true;
}
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 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 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)));
}
}
}