Пример #1
0
 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;
 }
Пример #2
0
 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;
 }
Пример #3
0
 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;
 }
Пример #4
0
 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;
 }
Пример #5
0
 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;
 }
Пример #6
0
 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;
 }
Пример #7
0
 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;
 }
Пример #8
0
 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;
 }
Пример #9
0
 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;
 }
Пример #10
0
 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;
 }
Пример #11
0
 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;
 }
Пример #12
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof 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;
 }
Пример #13
0
 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)));
     }
   }
 }
Пример #14
0
 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;
 }
Пример #16
0
 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)));
     }
   }
 }
Пример #18
0
 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;
 }
Пример #19
0
 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;
 }
Пример #23
0
 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;
 }
Пример #25
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)));
     }
   }
 }
Пример #26
0
 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;
 }
Пример #27
0
 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;
 }
Пример #28
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)));
     }
   }
 }
Пример #29
0
 public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
   final Object draftCopy = ((target == null) ? createNewInstance() : target);
   super.copyTo(locator, draftCopy, strategy);
   if (draftCopy instanceof PolygonType) {
     final PolygonType copy = ((PolygonType) draftCopy);
     if (this.isSetExterior()) {
       AbstractRingPropertyType sourceExterior;
       sourceExterior = this.getExterior();
       AbstractRingPropertyType copyExterior =
           ((AbstractRingPropertyType)
               strategy.copy(
                   LocatorUtils.property(locator, "exterior", sourceExterior), sourceExterior));
       copy.setExterior(copyExterior);
     } else {
       copy.exterior = null;
     }
     if (this.isSetInteriors()) {
       List<AbstractRingPropertyType> sourceInteriors;
       sourceInteriors = (this.isSetInteriors() ? this.getInteriors() : null);
       @SuppressWarnings("unchecked")
       List<AbstractRingPropertyType> copyInteriors =
           ((List<AbstractRingPropertyType>)
               strategy.copy(
                   LocatorUtils.property(locator, "interiors", sourceInteriors), sourceInteriors));
       copy.unsetInteriors();
       List<AbstractRingPropertyType> uniqueInteriorsl = copy.getInteriors();
       uniqueInteriorsl.addAll(copyInteriors);
     } else {
       copy.unsetInteriors();
     }
   }
   return draftCopy;
 }
Пример #30
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)));
     }
   }
 }