public Object copyTo(ObjectLocator locator, Object target, CopyStrategy strategy) {
final Object draftCopy = ((target == null) ? createNewInstance() : target);
super.copyTo(locator, draftCopy, strategy);
if (draftCopy instanceof EdgeType) {
final EdgeType copy = ((EdgeType) draftCopy);
if (this.isSetDirectedNode()) {
List<DirectedNodePropertyType> sourceDirectedNode;
sourceDirectedNode = this.getDirectedNode();
@SuppressWarnings("unchecked")
List<DirectedNodePropertyType> copyDirectedNode =
((List<DirectedNodePropertyType>)
strategy.copy(
LocatorUtils.property(locator, "directedNode", sourceDirectedNode),
sourceDirectedNode));
copy.unsetDirectedNode();
List<DirectedNodePropertyType> uniqueDirectedNodel = copy.getDirectedNode();
uniqueDirectedNodel.addAll(copyDirectedNode);
} else {
copy.unsetDirectedNode();
}
if (this.isSetDirectedFace()) {
List<DirectedFacePropertyType> sourceDirectedFace;
sourceDirectedFace = this.getDirectedFace();
@SuppressWarnings("unchecked")
List<DirectedFacePropertyType> copyDirectedFace =
((List<DirectedFacePropertyType>)
strategy.copy(
LocatorUtils.property(locator, "directedFace", sourceDirectedFace),
sourceDirectedFace));
copy.unsetDirectedFace();
List<DirectedFacePropertyType> uniqueDirectedFacel = copy.getDirectedFace();
uniqueDirectedFacel.addAll(copyDirectedFace);
} else {
copy.unsetDirectedFace();
}
if (this.isSetCurveProperty()) {
CurvePropertyType sourceCurveProperty;
sourceCurveProperty = this.getCurveProperty();
CurvePropertyType copyCurveProperty =
((CurvePropertyType)
strategy.copy(
LocatorUtils.property(locator, "curveProperty", sourceCurveProperty),
sourceCurveProperty));
copy.setCurveProperty(copyCurveProperty);
} else {
copy.curveProperty = null;
}
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) {
super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
if (right instanceof EdgeType) {
final EdgeType target = this;
final EdgeType leftObject = ((EdgeType) left);
final EdgeType rightObject = ((EdgeType) right);
{
List<DirectedNodePropertyType> lhsDirectedNode;
lhsDirectedNode = leftObject.getDirectedNode();
List<DirectedNodePropertyType> rhsDirectedNode;
rhsDirectedNode = rightObject.getDirectedNode();
target.unsetDirectedNode();
List<DirectedNodePropertyType> uniqueDirectedNodel = target.getDirectedNode();
uniqueDirectedNodel.addAll(
((List<DirectedNodePropertyType>)
strategy.merge(
LocatorUtils.property(leftLocator, "directedNode", lhsDirectedNode),
LocatorUtils.property(rightLocator, "directedNode", rhsDirectedNode),
lhsDirectedNode,
rhsDirectedNode)));
}
{
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)));
}
{
CurvePropertyType lhsCurveProperty;
lhsCurveProperty = leftObject.getCurveProperty();
CurvePropertyType rhsCurveProperty;
rhsCurveProperty = rightObject.getCurveProperty();
target.setCurveProperty(
((CurvePropertyType)
strategy.merge(
LocatorUtils.property(leftLocator, "curveProperty", lhsCurveProperty),
LocatorUtils.property(rightLocator, "curveProperty", rhsCurveProperty),
lhsCurveProperty,
rhsCurveProperty)));
}
{
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 boolean equals(
ObjectLocator thisLocator,
ObjectLocator thatLocator,
Object object,
EqualsStrategy strategy) {
if (!(object instanceof EdgeType)) {
return false;
}
if (this == object) {
return true;
}
if (!super.equals(thisLocator, thatLocator, object, strategy)) {
return false;
}
final EdgeType that = ((EdgeType) object);
{
List<DirectedNodePropertyType> lhsDirectedNode;
lhsDirectedNode = this.getDirectedNode();
List<DirectedNodePropertyType> rhsDirectedNode;
rhsDirectedNode = that.getDirectedNode();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "directedNode", lhsDirectedNode),
LocatorUtils.property(thatLocator, "directedNode", rhsDirectedNode),
lhsDirectedNode,
rhsDirectedNode)) {
return false;
}
}
{
List<DirectedFacePropertyType> lhsDirectedFace;
lhsDirectedFace = this.getDirectedFace();
List<DirectedFacePropertyType> rhsDirectedFace;
rhsDirectedFace = that.getDirectedFace();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "directedFace", lhsDirectedFace),
LocatorUtils.property(thatLocator, "directedFace", rhsDirectedFace),
lhsDirectedFace,
rhsDirectedFace)) {
return false;
}
}
{
CurvePropertyType lhsCurveProperty;
lhsCurveProperty = this.getCurveProperty();
CurvePropertyType rhsCurveProperty;
rhsCurveProperty = that.getCurveProperty();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "curveProperty", lhsCurveProperty),
LocatorUtils.property(thatLocator, "curveProperty", rhsCurveProperty),
lhsCurveProperty,
rhsCurveProperty)) {
return false;
}
}
{
AggregationType lhsAggregationType;
lhsAggregationType = this.getAggregationType();
AggregationType rhsAggregationType;
rhsAggregationType = that.getAggregationType();
if (!strategy.equals(
LocatorUtils.property(thisLocator, "aggregationType", lhsAggregationType),
LocatorUtils.property(thatLocator, "aggregationType", rhsAggregationType),
lhsAggregationType,
rhsAggregationType)) {
return false;
}
}
return true;
}