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 AbstractCoverageType)) {
return false;
}
if (this == object) {
return true;
}
if (!super.equals(thisLocator, thatLocator, object, strategy)) {
return false;
}
final AbstractCoverageType that = ((AbstractCoverageType) object);
{
JAXBElement<? extends DomainSetType> lhsDomainSet;
lhsDomainSet = this.getDomainSet();
JAXBElement<? extends DomainSetType> rhsDomainSet;
rhsDomainSet = that.getDomainSet();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "domainSet", lhsDomainSet),
LocatorUtils.property(thatLocator, "domainSet", rhsDomainSet),
lhsDomainSet,
rhsDomainSet)) {
return false;
}
}
{
RangeSetType lhsRangeSet;
lhsRangeSet = this.getRangeSet();
RangeSetType rhsRangeSet;
rhsRangeSet = that.getRangeSet();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "rangeSet", lhsRangeSet),
LocatorUtils.property(thatLocator, "rangeSet", rhsRangeSet),
lhsRangeSet,
rhsRangeSet)) {
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 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)));
}
}
}
