//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.11
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2016.07.27 at 04:06:37 PM EDT
//
package mil.ces.metadata.mdr.ns.gsip.tspi._2_0.core;
import java.io.Serializable;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
import net.opengis.gml.v_3_2_1.AbstractSurfaceType;
import net.opengis.gml.v_3_2_1.DirectPositionType;
import net.opengis.gml.v_3_2_1.PointPropertyType;
import org.jvnet.jaxb2_commons.lang.CopyStrategy2;
import org.jvnet.jaxb2_commons.lang.CopyTo2;
import org.jvnet.jaxb2_commons.lang.Equals2;
import org.jvnet.jaxb2_commons.lang.EqualsStrategy2;
import org.jvnet.jaxb2_commons.lang.HashCode2;
import org.jvnet.jaxb2_commons.lang.HashCodeStrategy2;
import org.jvnet.jaxb2_commons.lang.JAXBCopyStrategy;
import org.jvnet.jaxb2_commons.lang.JAXBEqualsStrategy;
import org.jvnet.jaxb2_commons.lang.JAXBHashCodeStrategy;
import org.jvnet.jaxb2_commons.lang.JAXBMergeStrategy;
import org.jvnet.jaxb2_commons.lang.JAXBToStringStrategy;
import org.jvnet.jaxb2_commons.lang.MergeFrom2;
import org.jvnet.jaxb2_commons.lang.MergeStrategy2;
import org.jvnet.jaxb2_commons.lang.ToString2;
import org.jvnet.jaxb2_commons.lang.ToStringStrategy2;
import org.jvnet.jaxb2_commons.locator.ObjectLocator;
import org.jvnet.jaxb2_commons.locator.util.LocatorUtils;
/**
* Elliptical Surface Type: An elliptical surface type, as developed based on ISO 19136:2007 (GML) Polygon for use in the TSPI Schema but defined in terms of the content model of a circle and then extended to include both assessments of the accuracy and/or resolution of the coordinate tuples as well as optional specification of one or more character-oriented presentations of the coordinate tuples based on the sexagesimal, grid-metre, zone-metre, quadrangle and/or numeric-bit location forms. An ellipse is an arc that is specified by a center point, and oriented semi-major/semi-minor axes of specified length. This representation can be used only in 2D.
*
* <p>Java class for EllipticalSurfaceType complex type.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <complexType name="EllipticalSurfaceType">
* <complexContent>
* <extension base="{http://www.opengis.net/gml/3.2}AbstractSurfaceType">
* <sequence>
* <choice>
* <element ref="{http://www.opengis.net/gml/3.2}pos"/>
* <element ref="{http://www.opengis.net/gml/3.2}pointProperty"/>
* </choice>
* <element name="semiMajorLength" type="{http://metadata.ces.mil/mdr/ns/GSIP/tspi/2.0/core}LengthType"/>
* <element name="semiMinorLength" type="{http://metadata.ces.mil/mdr/ns/GSIP/tspi/2.0/core}LengthType"/>
* <element name="orientation" type="{http://metadata.ces.mil/mdr/ns/GSIP/tspi/2.0/core}PlaneAngleType"/>
* <group ref="{http://metadata.ces.mil/mdr/ns/GSIP/tspi/2.0/core}resolutionGroup"/>
* <group ref="{http://metadata.ces.mil/mdr/ns/GSIP/tspi/2.0/core}presentationGroup"/>
* </sequence>
* </extension>
* </complexContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "EllipticalSurfaceType", propOrder = {
"pos",
"pointProperty",
"semiMajorLength",
"semiMinorLength",
"orientation",
"horizResolutionCategory",
"vertResolutionCategory",
"horizPresentation",
"vertPresentation"
})
public class EllipticalSurfaceType
extends AbstractSurfaceType
implements Serializable, Cloneable, CopyTo2, Equals2, HashCode2, MergeFrom2, ToString2
{
private final static long serialVersionUID = 1L;
@XmlElement(namespace = "http://www.opengis.net/gml/3.2")
@Valid
protected DirectPositionType pos;
@XmlElement(namespace = "http://www.opengis.net/gml/3.2")
@Valid
protected PointPropertyType pointProperty;
@XmlElement(required = true)
@NotNull(message = "EllipticalSurfaceType.semiMajorLength {javax.validation.constraints.NotNull.message}")
@Valid
protected LengthType semiMajorLength;
@XmlElement(required = true)
@NotNull(message = "EllipticalSurfaceType.semiMinorLength {javax.validation.constraints.NotNull.message}")
@Valid
protected LengthType semiMinorLength;
@XmlElement(required = true)
@NotNull(message = "EllipticalSurfaceType.orientation {javax.validation.constraints.NotNull.message}")
@Valid
protected PlaneAngleType orientation;
@Valid
protected HorizontalResolutionType horizResolutionCategory;
@Valid
protected VerticalResolutionType vertResolutionCategory;
@Valid
protected HorizontalPresentationType horizPresentation;
@Valid
protected VerticalPresentationType vertPresentation;
/**
* Gets the value of the pos property.
*
* @return
* possible object is
* {@link DirectPositionType }
*
*/
public DirectPositionType getPos() {
return pos;
}
/**
* Sets the value of the pos property.
*
* @param value
* allowed object is
* {@link DirectPositionType }
*
*/
public void setPos(DirectPositionType value) {
this.pos = value;
}
public boolean isSetPos() {
return (this.pos!= null);
}
/**
* Gets the value of the pointProperty property.
*
* @return
* possible object is
* {@link PointPropertyType }
*
*/
public PointPropertyType getPointProperty() {
return pointProperty;
}
/**
* Sets the value of the pointProperty property.
*
* @param value
* allowed object is
* {@link PointPropertyType }
*
*/
public void setPointProperty(PointPropertyType value) {
this.pointProperty = value;
}
public boolean isSetPointProperty() {
return (this.pointProperty!= null);
}
/**
* Gets the value of the semiMajorLength property.
*
* @return
* possible object is
* {@link LengthType }
*
*/
public LengthType getSemiMajorLength() {
return semiMajorLength;
}
/**
* Sets the value of the semiMajorLength property.
*
* @param value
* allowed object is
* {@link LengthType }
*
*/
public void setSemiMajorLength(LengthType value) {
this.semiMajorLength = value;
}
public boolean isSetSemiMajorLength() {
return (this.semiMajorLength!= null);
}
/**
* Gets the value of the semiMinorLength property.
*
* @return
* possible object is
* {@link LengthType }
*
*/
public LengthType getSemiMinorLength() {
return semiMinorLength;
}
/**
* Sets the value of the semiMinorLength property.
*
* @param value
* allowed object is
* {@link LengthType }
*
*/
public void setSemiMinorLength(LengthType value) {
this.semiMinorLength = value;
}
public boolean isSetSemiMinorLength() {
return (this.semiMinorLength!= null);
}
/**
* Gets the value of the orientation property.
*
* @return
* possible object is
* {@link PlaneAngleType }
*
*/
public PlaneAngleType getOrientation() {
return orientation;
}
/**
* Sets the value of the orientation property.
*
* @param value
* allowed object is
* {@link PlaneAngleType }
*
*/
public void setOrientation(PlaneAngleType value) {
this.orientation = value;
}
public boolean isSetOrientation() {
return (this.orientation!= null);
}
/**
* Gets the value of the horizResolutionCategory property.
*
* @return
* possible object is
* {@link HorizontalResolutionType }
*
*/
public HorizontalResolutionType getHorizResolutionCategory() {
return horizResolutionCategory;
}
/**
* Sets the value of the horizResolutionCategory property.
*
* @param value
* allowed object is
* {@link HorizontalResolutionType }
*
*/
public void setHorizResolutionCategory(HorizontalResolutionType value) {
this.horizResolutionCategory = value;
}
public boolean isSetHorizResolutionCategory() {
return (this.horizResolutionCategory!= null);
}
/**
* Gets the value of the vertResolutionCategory property.
*
* @return
* possible object is
* {@link VerticalResolutionType }
*
*/
public VerticalResolutionType getVertResolutionCategory() {
return vertResolutionCategory;
}
/**
* Sets the value of the vertResolutionCategory property.
*
* @param value
* allowed object is
* {@link VerticalResolutionType }
*
*/
public void setVertResolutionCategory(VerticalResolutionType value) {
this.vertResolutionCategory = value;
}
public boolean isSetVertResolutionCategory() {
return (this.vertResolutionCategory!= null);
}
/**
* Gets the value of the horizPresentation property.
*
* @return
* possible object is
* {@link HorizontalPresentationType }
*
*/
public HorizontalPresentationType getHorizPresentation() {
return horizPresentation;
}
/**
* Sets the value of the horizPresentation property.
*
* @param value
* allowed object is
* {@link HorizontalPresentationType }
*
*/
public void setHorizPresentation(HorizontalPresentationType value) {
this.horizPresentation = value;
}
public boolean isSetHorizPresentation() {
return (this.horizPresentation!= null);
}
/**
* Gets the value of the vertPresentation property.
*
* @return
* possible object is
* {@link VerticalPresentationType }
*
*/
public VerticalPresentationType getVertPresentation() {
return vertPresentation;
}
/**
* Sets the value of the vertPresentation property.
*
* @param value
* allowed object is
* {@link VerticalPresentationType }
*
*/
public void setVertPresentation(VerticalPresentationType value) {
this.vertPresentation = value;
}
public boolean isSetVertPresentation() {
return (this.vertPresentation!= null);
}
public String toString() {
final ToStringStrategy2 strategy = JAXBToStringStrategy.INSTANCE;
final StringBuilder buffer = new StringBuilder();
append(null, buffer, strategy);
return buffer.toString();
}
public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy2 strategy) {
strategy.appendStart(locator, this, buffer);
appendFields(locator, buffer, strategy);
strategy.appendEnd(locator, this, buffer);
return buffer;
}
public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy2 strategy) {
super.appendFields(locator, buffer, strategy);
{
DirectPositionType thePos;
thePos = this.getPos();
strategy.appendField(locator, this, "pos", buffer, thePos, this.isSetPos());
}
{
PointPropertyType thePointProperty;
thePointProperty = this.getPointProperty();
strategy.appendField(locator, this, "pointProperty", buffer, thePointProperty, this.isSetPointProperty());
}
{
LengthType theSemiMajorLength;
theSemiMajorLength = this.getSemiMajorLength();
strategy.appendField(locator, this, "semiMajorLength", buffer, theSemiMajorLength, this.isSetSemiMajorLength());
}
{
LengthType theSemiMinorLength;
theSemiMinorLength = this.getSemiMinorLength();
strategy.appendField(locator, this, "semiMinorLength", buffer, theSemiMinorLength, this.isSetSemiMinorLength());
}
{
PlaneAngleType theOrientation;
theOrientation = this.getOrientation();
strategy.appendField(locator, this, "orientation", buffer, theOrientation, this.isSetOrientation());
}
{
HorizontalResolutionType theHorizResolutionCategory;
theHorizResolutionCategory = this.getHorizResolutionCategory();
strategy.appendField(locator, this, "horizResolutionCategory", buffer, theHorizResolutionCategory, this.isSetHorizResolutionCategory());
}
{
VerticalResolutionType theVertResolutionCategory;
theVertResolutionCategory = this.getVertResolutionCategory();
strategy.appendField(locator, this, "vertResolutionCategory", buffer, theVertResolutionCategory, this.isSetVertResolutionCategory());
}
{
HorizontalPresentationType theHorizPresentation;
theHorizPresentation = this.getHorizPresentation();
strategy.appendField(locator, this, "horizPresentation", buffer, theHorizPresentation, this.isSetHorizPresentation());
}
{
VerticalPresentationType theVertPresentation;
theVertPresentation = this.getVertPresentation();
strategy.appendField(locator, this, "vertPresentation", buffer, theVertPresentation, this.isSetVertPresentation());
}
return buffer;
}
public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy2 strategy) {
if ((object == null)||(this.getClass()!= object.getClass())) {
return false;
}
if (this == object) {
return true;
}
if (!super.equals(thisLocator, thatLocator, object, strategy)) {
return false;
}
final EllipticalSurfaceType that = ((EllipticalSurfaceType) object);
{
DirectPositionType lhsPos;
lhsPos = this.getPos();
DirectPositionType rhsPos;
rhsPos = that.getPos();
if (!strategy.equals(LocatorUtils.property(thisLocator, "pos", lhsPos), LocatorUtils.property(thatLocator, "pos", rhsPos), lhsPos, rhsPos, this.isSetPos(), that.isSetPos())) {
return false;
}
}
{
PointPropertyType lhsPointProperty;
lhsPointProperty = this.getPointProperty();
PointPropertyType rhsPointProperty;
rhsPointProperty = that.getPointProperty();
if (!strategy.equals(LocatorUtils.property(thisLocator, "pointProperty", lhsPointProperty), LocatorUtils.property(thatLocator, "pointProperty", rhsPointProperty), lhsPointProperty, rhsPointProperty, this.isSetPointProperty(), that.isSetPointProperty())) {
return false;
}
}
{
LengthType lhsSemiMajorLength;
lhsSemiMajorLength = this.getSemiMajorLength();
LengthType rhsSemiMajorLength;
rhsSemiMajorLength = that.getSemiMajorLength();
if (!strategy.equals(LocatorUtils.property(thisLocator, "semiMajorLength", lhsSemiMajorLength), LocatorUtils.property(thatLocator, "semiMajorLength", rhsSemiMajorLength), lhsSemiMajorLength, rhsSemiMajorLength, this.isSetSemiMajorLength(), that.isSetSemiMajorLength())) {
return false;
}
}
{
LengthType lhsSemiMinorLength;
lhsSemiMinorLength = this.getSemiMinorLength();
LengthType rhsSemiMinorLength;
rhsSemiMinorLength = that.getSemiMinorLength();
if (!strategy.equals(LocatorUtils.property(thisLocator, "semiMinorLength", lhsSemiMinorLength), LocatorUtils.property(thatLocator, "semiMinorLength", rhsSemiMinorLength), lhsSemiMinorLength, rhsSemiMinorLength, this.isSetSemiMinorLength(), that.isSetSemiMinorLength())) {
return false;
}
}
{
PlaneAngleType lhsOrientation;
lhsOrientation = this.getOrientation();
PlaneAngleType rhsOrientation;
rhsOrientation = that.getOrientation();
if (!strategy.equals(LocatorUtils.property(thisLocator, "orientation", lhsOrientation), LocatorUtils.property(thatLocator, "orientation", rhsOrientation), lhsOrientation, rhsOrientation, this.isSetOrientation(), that.isSetOrientation())) {
return false;
}
}
{
HorizontalResolutionType lhsHorizResolutionCategory;
lhsHorizResolutionCategory = this.getHorizResolutionCategory();
HorizontalResolutionType rhsHorizResolutionCategory;
rhsHorizResolutionCategory = that.getHorizResolutionCategory();
if (!strategy.equals(LocatorUtils.property(thisLocator, "horizResolutionCategory", lhsHorizResolutionCategory), LocatorUtils.property(thatLocator, "horizResolutionCategory", rhsHorizResolutionCategory), lhsHorizResolutionCategory, rhsHorizResolutionCategory, this.isSetHorizResolutionCategory(), that.isSetHorizResolutionCategory())) {
return false;
}
}
{
VerticalResolutionType lhsVertResolutionCategory;
lhsVertResolutionCategory = this.getVertResolutionCategory();
VerticalResolutionType rhsVertResolutionCategory;
rhsVertResolutionCategory = that.getVertResolutionCategory();
if (!strategy.equals(LocatorUtils.property(thisLocator, "vertResolutionCategory", lhsVertResolutionCategory), LocatorUtils.property(thatLocator, "vertResolutionCategory", rhsVertResolutionCategory), lhsVertResolutionCategory, rhsVertResolutionCategory, this.isSetVertResolutionCategory(), that.isSetVertResolutionCategory())) {
return false;
}
}
{
HorizontalPresentationType lhsHorizPresentation;
lhsHorizPresentation = this.getHorizPresentation();
HorizontalPresentationType rhsHorizPresentation;
rhsHorizPresentation = that.getHorizPresentation();
if (!strategy.equals(LocatorUtils.property(thisLocator, "horizPresentation", lhsHorizPresentation), LocatorUtils.property(thatLocator, "horizPresentation", rhsHorizPresentation), lhsHorizPresentation, rhsHorizPresentation, this.isSetHorizPresentation(), that.isSetHorizPresentation())) {
return false;
}
}
{
VerticalPresentationType lhsVertPresentation;
lhsVertPresentation = this.getVertPresentation();
VerticalPresentationType rhsVertPresentation;
rhsVertPresentation = that.getVertPresentation();
if (!strategy.equals(LocatorUtils.property(thisLocator, "vertPresentation", lhsVertPresentation), LocatorUtils.property(thatLocator, "vertPresentation", rhsVertPresentation), lhsVertPresentation, rhsVertPresentation, this.isSetVertPresentation(), that.isSetVertPresentation())) {
return false;
}
}
return true;
}
public boolean equals(Object object) {
final EqualsStrategy2 strategy = JAXBEqualsStrategy.INSTANCE;
return equals(null, null, object, strategy);
}
public int hashCode(ObjectLocator locator, HashCodeStrategy2 strategy) {
int currentHashCode = super.hashCode(locator, strategy);
{
DirectPositionType thePos;
thePos = this.getPos();
currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "pos", thePos), currentHashCode, thePos, this.isSetPos());
}
{
PointPropertyType thePointProperty;
thePointProperty = this.getPointProperty();
currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "pointProperty", thePointProperty), currentHashCode, thePointProperty, this.isSetPointProperty());
}
{
LengthType theSemiMajorLength;
theSemiMajorLength = this.getSemiMajorLength();
currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "semiMajorLength", theSemiMajorLength), currentHashCode, theSemiMajorLength, this.isSetSemiMajorLength());
}
{
LengthType theSemiMinorLength;
theSemiMinorLength = this.getSemiMinorLength();
currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "semiMinorLength", theSemiMinorLength), currentHashCode, theSemiMinorLength, this.isSetSemiMinorLength());
}
{
PlaneAngleType theOrientation;
theOrientation = this.getOrientation();
currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "orientation", theOrientation), currentHashCode, theOrientation, this.isSetOrientation());
}
{
HorizontalResolutionType theHorizResolutionCategory;
theHorizResolutionCategory = this.getHorizResolutionCategory();
currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "horizResolutionCategory", theHorizResolutionCategory), currentHashCode, theHorizResolutionCategory, this.isSetHorizResolutionCategory());
}
{
VerticalResolutionType theVertResolutionCategory;
theVertResolutionCategory = this.getVertResolutionCategory();
currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "vertResolutionCategory", theVertResolutionCategory), currentHashCode, theVertResolutionCategory, this.isSetVertResolutionCategory());
}
{
HorizontalPresentationType theHorizPresentation;
theHorizPresentation = this.getHorizPresentation();
currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "horizPresentation", theHorizPresentation), currentHashCode, theHorizPresentation, this.isSetHorizPresentation());
}
{
VerticalPresentationType theVertPresentation;
theVertPresentation = this.getVertPresentation();
currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "vertPresentation", theVertPresentation), currentHashCode, theVertPresentation, this.isSetVertPresentation());
}
return currentHashCode;
}
public int hashCode() {
final HashCodeStrategy2 strategy = JAXBHashCodeStrategy.INSTANCE;
return this.hashCode(null, strategy);
}
public Object clone() {
return copyTo(createNewInstance());
}
public Object copyTo(Object target) {
final CopyStrategy2 strategy = JAXBCopyStrategy.INSTANCE;
return copyTo(null, target, strategy);
}
public Object copyTo(ObjectLocator locator, Object target, CopyStrategy2 strategy) {
final Object draftCopy = ((target == null)?createNewInstance():target);
super.copyTo(locator, draftCopy, strategy);
if (draftCopy instanceof EllipticalSurfaceType) {
final EllipticalSurfaceType copy = ((EllipticalSurfaceType) draftCopy);
{
Boolean posShouldBeCopiedAndSet = strategy.shouldBeCopiedAndSet(locator, this.isSetPos());
if (posShouldBeCopiedAndSet == Boolean.TRUE) {
DirectPositionType sourcePos;
sourcePos = this.getPos();
DirectPositionType copyPos = ((DirectPositionType) strategy.copy(LocatorUtils.property(locator, "pos", sourcePos), sourcePos, this.isSetPos()));
copy.setPos(copyPos);
} else {
if (posShouldBeCopiedAndSet == Boolean.FALSE) {
copy.pos = null;
}
}
}
{
Boolean pointPropertyShouldBeCopiedAndSet = strategy.shouldBeCopiedAndSet(locator, this.isSetPointProperty());
if (pointPropertyShouldBeCopiedAndSet == Boolean.TRUE) {
PointPropertyType sourcePointProperty;
sourcePointProperty = this.getPointProperty();
PointPropertyType copyPointProperty = ((PointPropertyType) strategy.copy(LocatorUtils.property(locator, "pointProperty", sourcePointProperty), sourcePointProperty, this.isSetPointProperty()));
copy.setPointProperty(copyPointProperty);
} else {
if (pointPropertyShouldBeCopiedAndSet == Boolean.FALSE) {
copy.pointProperty = null;
}
}
}
{
Boolean semiMajorLengthShouldBeCopiedAndSet = strategy.shouldBeCopiedAndSet(locator, this.isSetSemiMajorLength());
if (semiMajorLengthShouldBeCopiedAndSet == Boolean.TRUE) {
LengthType sourceSemiMajorLength;
sourceSemiMajorLength = this.getSemiMajorLength();
LengthType copySemiMajorLength = ((LengthType) strategy.copy(LocatorUtils.property(locator, "semiMajorLength", sourceSemiMajorLength), sourceSemiMajorLength, this.isSetSemiMajorLength()));
copy.setSemiMajorLength(copySemiMajorLength);
} else {
if (semiMajorLengthShouldBeCopiedAndSet == Boolean.FALSE) {
copy.semiMajorLength = null;
}
}
}
{
Boolean semiMinorLengthShouldBeCopiedAndSet = strategy.shouldBeCopiedAndSet(locator, this.isSetSemiMinorLength());
if (semiMinorLengthShouldBeCopiedAndSet == Boolean.TRUE) {
LengthType sourceSemiMinorLength;
sourceSemiMinorLength = this.getSemiMinorLength();
LengthType copySemiMinorLength = ((LengthType) strategy.copy(LocatorUtils.property(locator, "semiMinorLength", sourceSemiMinorLength), sourceSemiMinorLength, this.isSetSemiMinorLength()));
copy.setSemiMinorLength(copySemiMinorLength);
} else {
if (semiMinorLengthShouldBeCopiedAndSet == Boolean.FALSE) {
copy.semiMinorLength = null;
}
}
}
{
Boolean orientationShouldBeCopiedAndSet = strategy.shouldBeCopiedAndSet(locator, this.isSetOrientation());
if (orientationShouldBeCopiedAndSet == Boolean.TRUE) {
PlaneAngleType sourceOrientation;
sourceOrientation = this.getOrientation();
PlaneAngleType copyOrientation = ((PlaneAngleType) strategy.copy(LocatorUtils.property(locator, "orientation", sourceOrientation), sourceOrientation, this.isSetOrientation()));
copy.setOrientation(copyOrientation);
} else {
if (orientationShouldBeCopiedAndSet == Boolean.FALSE) {
copy.orientation = null;
}
}
}
{
Boolean horizResolutionCategoryShouldBeCopiedAndSet = strategy.shouldBeCopiedAndSet(locator, this.isSetHorizResolutionCategory());
if (horizResolutionCategoryShouldBeCopiedAndSet == Boolean.TRUE) {
HorizontalResolutionType sourceHorizResolutionCategory;
sourceHorizResolutionCategory = this.getHorizResolutionCategory();
HorizontalResolutionType copyHorizResolutionCategory = ((HorizontalResolutionType) strategy.copy(LocatorUtils.property(locator, "horizResolutionCategory", sourceHorizResolutionCategory), sourceHorizResolutionCategory, this.isSetHorizResolutionCategory()));
copy.setHorizResolutionCategory(copyHorizResolutionCategory);
} else {
if (horizResolutionCategoryShouldBeCopiedAndSet == Boolean.FALSE) {
copy.horizResolutionCategory = null;
}
}
}
{
Boolean vertResolutionCategoryShouldBeCopiedAndSet = strategy.shouldBeCopiedAndSet(locator, this.isSetVertResolutionCategory());
if (vertResolutionCategoryShouldBeCopiedAndSet == Boolean.TRUE) {
VerticalResolutionType sourceVertResolutionCategory;
sourceVertResolutionCategory = this.getVertResolutionCategory();
VerticalResolutionType copyVertResolutionCategory = ((VerticalResolutionType) strategy.copy(LocatorUtils.property(locator, "vertResolutionCategory", sourceVertResolutionCategory), sourceVertResolutionCategory, this.isSetVertResolutionCategory()));
copy.setVertResolutionCategory(copyVertResolutionCategory);
} else {
if (vertResolutionCategoryShouldBeCopiedAndSet == Boolean.FALSE) {
copy.vertResolutionCategory = null;
}
}
}
{
Boolean horizPresentationShouldBeCopiedAndSet = strategy.shouldBeCopiedAndSet(locator, this.isSetHorizPresentation());
if (horizPresentationShouldBeCopiedAndSet == Boolean.TRUE) {
HorizontalPresentationType sourceHorizPresentation;
sourceHorizPresentation = this.getHorizPresentation();
HorizontalPresentationType copyHorizPresentation = ((HorizontalPresentationType) strategy.copy(LocatorUtils.property(locator, "horizPresentation", sourceHorizPresentation), sourceHorizPresentation, this.isSetHorizPresentation()));
copy.setHorizPresentation(copyHorizPresentation);
} else {
if (horizPresentationShouldBeCopiedAndSet == Boolean.FALSE) {
copy.horizPresentation = null;
}
}
}
{
Boolean vertPresentationShouldBeCopiedAndSet = strategy.shouldBeCopiedAndSet(locator, this.isSetVertPresentation());
if (vertPresentationShouldBeCopiedAndSet == Boolean.TRUE) {
VerticalPresentationType sourceVertPresentation;
sourceVertPresentation = this.getVertPresentation();
VerticalPresentationType copyVertPresentation = ((VerticalPresentationType) strategy.copy(LocatorUtils.property(locator, "vertPresentation", sourceVertPresentation), sourceVertPresentation, this.isSetVertPresentation()));
copy.setVertPresentation(copyVertPresentation);
} else {
if (vertPresentationShouldBeCopiedAndSet == Boolean.FALSE) {
copy.vertPresentation = null;
}
}
}
}
return draftCopy;
}
public Object createNewInstance() {
return new EllipticalSurfaceType();
}
public void mergeFrom(Object left, Object right) {
final MergeStrategy2 strategy = JAXBMergeStrategy.INSTANCE;
mergeFrom(null, null, left, right, strategy);
}
public void mergeFrom(ObjectLocator leftLocator, ObjectLocator rightLocator, Object left, Object right, MergeStrategy2 strategy) {
super.mergeFrom(leftLocator, rightLocator, left, right, strategy);
if (right instanceof EllipticalSurfaceType) {
final EllipticalSurfaceType target = this;
final EllipticalSurfaceType leftObject = ((EllipticalSurfaceType) left);
final EllipticalSurfaceType rightObject = ((EllipticalSurfaceType) right);
{
Boolean posShouldBeMergedAndSet = strategy.shouldBeMergedAndSet(leftLocator, rightLocator, leftObject.isSetPos(), rightObject.isSetPos());
if (posShouldBeMergedAndSet == Boolean.TRUE) {
DirectPositionType lhsPos;
lhsPos = leftObject.getPos();
DirectPositionType rhsPos;
rhsPos = rightObject.getPos();
DirectPositionType mergedPos = ((DirectPositionType) strategy.merge(LocatorUtils.property(leftLocator, "pos", lhsPos), LocatorUtils.property(rightLocator, "pos", rhsPos), lhsPos, rhsPos, leftObject.isSetPos(), rightObject.isSetPos()));
target.setPos(mergedPos);
} else {
if (posShouldBeMergedAndSet == Boolean.FALSE) {
target.pos = null;
}
}
}
{
Boolean pointPropertyShouldBeMergedAndSet = strategy.shouldBeMergedAndSet(leftLocator, rightLocator, leftObject.isSetPointProperty(), rightObject.isSetPointProperty());
if (pointPropertyShouldBeMergedAndSet == Boolean.TRUE) {
PointPropertyType lhsPointProperty;
lhsPointProperty = leftObject.getPointProperty();
PointPropertyType rhsPointProperty;
rhsPointProperty = rightObject.getPointProperty();
PointPropertyType mergedPointProperty = ((PointPropertyType) strategy.merge(LocatorUtils.property(leftLocator, "pointProperty", lhsPointProperty), LocatorUtils.property(rightLocator, "pointProperty", rhsPointProperty), lhsPointProperty, rhsPointProperty, leftObject.isSetPointProperty(), rightObject.isSetPointProperty()));
target.setPointProperty(mergedPointProperty);
} else {
if (pointPropertyShouldBeMergedAndSet == Boolean.FALSE) {
target.pointProperty = null;
}
}
}
{
Boolean semiMajorLengthShouldBeMergedAndSet = strategy.shouldBeMergedAndSet(leftLocator, rightLocator, leftObject.isSetSemiMajorLength(), rightObject.isSetSemiMajorLength());
if (semiMajorLengthShouldBeMergedAndSet == Boolean.TRUE) {
LengthType lhsSemiMajorLength;
lhsSemiMajorLength = leftObject.getSemiMajorLength();
LengthType rhsSemiMajorLength;
rhsSemiMajorLength = rightObject.getSemiMajorLength();
LengthType mergedSemiMajorLength = ((LengthType) strategy.merge(LocatorUtils.property(leftLocator, "semiMajorLength", lhsSemiMajorLength), LocatorUtils.property(rightLocator, "semiMajorLength", rhsSemiMajorLength), lhsSemiMajorLength, rhsSemiMajorLength, leftObject.isSetSemiMajorLength(), rightObject.isSetSemiMajorLength()));
target.setSemiMajorLength(mergedSemiMajorLength);
} else {
if (semiMajorLengthShouldBeMergedAndSet == Boolean.FALSE) {
target.semiMajorLength = null;
}
}
}
{
Boolean semiMinorLengthShouldBeMergedAndSet = strategy.shouldBeMergedAndSet(leftLocator, rightLocator, leftObject.isSetSemiMinorLength(), rightObject.isSetSemiMinorLength());
if (semiMinorLengthShouldBeMergedAndSet == Boolean.TRUE) {
LengthType lhsSemiMinorLength;
lhsSemiMinorLength = leftObject.getSemiMinorLength();
LengthType rhsSemiMinorLength;
rhsSemiMinorLength = rightObject.getSemiMinorLength();
LengthType mergedSemiMinorLength = ((LengthType) strategy.merge(LocatorUtils.property(leftLocator, "semiMinorLength", lhsSemiMinorLength), LocatorUtils.property(rightLocator, "semiMinorLength", rhsSemiMinorLength), lhsSemiMinorLength, rhsSemiMinorLength, leftObject.isSetSemiMinorLength(), rightObject.isSetSemiMinorLength()));
target.setSemiMinorLength(mergedSemiMinorLength);
} else {
if (semiMinorLengthShouldBeMergedAndSet == Boolean.FALSE) {
target.semiMinorLength = null;
}
}
}
{
Boolean orientationShouldBeMergedAndSet = strategy.shouldBeMergedAndSet(leftLocator, rightLocator, leftObject.isSetOrientation(), rightObject.isSetOrientation());
if (orientationShouldBeMergedAndSet == Boolean.TRUE) {
PlaneAngleType lhsOrientation;
lhsOrientation = leftObject.getOrientation();
PlaneAngleType rhsOrientation;
rhsOrientation = rightObject.getOrientation();
PlaneAngleType mergedOrientation = ((PlaneAngleType) strategy.merge(LocatorUtils.property(leftLocator, "orientation", lhsOrientation), LocatorUtils.property(rightLocator, "orientation", rhsOrientation), lhsOrientation, rhsOrientation, leftObject.isSetOrientation(), rightObject.isSetOrientation()));
target.setOrientation(mergedOrientation);
} else {
if (orientationShouldBeMergedAndSet == Boolean.FALSE) {
target.orientation = null;
}
}
}
{
Boolean horizResolutionCategoryShouldBeMergedAndSet = strategy.shouldBeMergedAndSet(leftLocator, rightLocator, leftObject.isSetHorizResolutionCategory(), rightObject.isSetHorizResolutionCategory());
if (horizResolutionCategoryShouldBeMergedAndSet == Boolean.TRUE) {
HorizontalResolutionType lhsHorizResolutionCategory;
lhsHorizResolutionCategory = leftObject.getHorizResolutionCategory();
HorizontalResolutionType rhsHorizResolutionCategory;
rhsHorizResolutionCategory = rightObject.getHorizResolutionCategory();
HorizontalResolutionType mergedHorizResolutionCategory = ((HorizontalResolutionType) strategy.merge(LocatorUtils.property(leftLocator, "horizResolutionCategory", lhsHorizResolutionCategory), LocatorUtils.property(rightLocator, "horizResolutionCategory", rhsHorizResolutionCategory), lhsHorizResolutionCategory, rhsHorizResolutionCategory, leftObject.isSetHorizResolutionCategory(), rightObject.isSetHorizResolutionCategory()));
target.setHorizResolutionCategory(mergedHorizResolutionCategory);
} else {
if (horizResolutionCategoryShouldBeMergedAndSet == Boolean.FALSE) {
target.horizResolutionCategory = null;
}
}
}
{
Boolean vertResolutionCategoryShouldBeMergedAndSet = strategy.shouldBeMergedAndSet(leftLocator, rightLocator, leftObject.isSetVertResolutionCategory(), rightObject.isSetVertResolutionCategory());
if (vertResolutionCategoryShouldBeMergedAndSet == Boolean.TRUE) {
VerticalResolutionType lhsVertResolutionCategory;
lhsVertResolutionCategory = leftObject.getVertResolutionCategory();
VerticalResolutionType rhsVertResolutionCategory;
rhsVertResolutionCategory = rightObject.getVertResolutionCategory();
VerticalResolutionType mergedVertResolutionCategory = ((VerticalResolutionType) strategy.merge(LocatorUtils.property(leftLocator, "vertResolutionCategory", lhsVertResolutionCategory), LocatorUtils.property(rightLocator, "vertResolutionCategory", rhsVertResolutionCategory), lhsVertResolutionCategory, rhsVertResolutionCategory, leftObject.isSetVertResolutionCategory(), rightObject.isSetVertResolutionCategory()));
target.setVertResolutionCategory(mergedVertResolutionCategory);
} else {
if (vertResolutionCategoryShouldBeMergedAndSet == Boolean.FALSE) {
target.vertResolutionCategory = null;
}
}
}
{
Boolean horizPresentationShouldBeMergedAndSet = strategy.shouldBeMergedAndSet(leftLocator, rightLocator, leftObject.isSetHorizPresentation(), rightObject.isSetHorizPresentation());
if (horizPresentationShouldBeMergedAndSet == Boolean.TRUE) {
HorizontalPresentationType lhsHorizPresentation;
lhsHorizPresentation = leftObject.getHorizPresentation();
HorizontalPresentationType rhsHorizPresentation;
rhsHorizPresentation = rightObject.getHorizPresentation();
HorizontalPresentationType mergedHorizPresentation = ((HorizontalPresentationType) strategy.merge(LocatorUtils.property(leftLocator, "horizPresentation", lhsHorizPresentation), LocatorUtils.property(rightLocator, "horizPresentation", rhsHorizPresentation), lhsHorizPresentation, rhsHorizPresentation, leftObject.isSetHorizPresentation(), rightObject.isSetHorizPresentation()));
target.setHorizPresentation(mergedHorizPresentation);
} else {
if (horizPresentationShouldBeMergedAndSet == Boolean.FALSE) {
target.horizPresentation = null;
}
}
}
{
Boolean vertPresentationShouldBeMergedAndSet = strategy.shouldBeMergedAndSet(leftLocator, rightLocator, leftObject.isSetVertPresentation(), rightObject.isSetVertPresentation());
if (vertPresentationShouldBeMergedAndSet == Boolean.TRUE) {
VerticalPresentationType lhsVertPresentation;
lhsVertPresentation = leftObject.getVertPresentation();
VerticalPresentationType rhsVertPresentation;
rhsVertPresentation = rightObject.getVertPresentation();
VerticalPresentationType mergedVertPresentation = ((VerticalPresentationType) strategy.merge(LocatorUtils.property(leftLocator, "vertPresentation", lhsVertPresentation), LocatorUtils.property(rightLocator, "vertPresentation", rhsVertPresentation), lhsVertPresentation, rhsVertPresentation, leftObject.isSetVertPresentation(), rightObject.isSetVertPresentation()));
target.setVertPresentation(mergedVertPresentation);
} else {
if (vertPresentationShouldBeMergedAndSet == Boolean.FALSE) {
target.vertPresentation = null;
}
}
}
}
}
}