Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  //
  // This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vhudson-jaxb-ri-2.1-2 
  // 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: 2010.09.03 at 10:11:56 AM MESZ 
  //
  
  
  package net.opengis.xls.v_1_1_0;
 

Java class for EllipseType complex type.

The following schema fragment specifies the expected content contained within this class.

 <complexType name="EllipseType">
   <complexContent>
     <extension base="{http://www.opengis.net/gml}AbstractGeometricPrimitiveType">
       <sequence>
         <element ref="{http://www.opengis.net/gml}pos"/>
         <element name="majorAxis" type="{http://www.opengis.net/gml}LengthType"/>
         <element name="minorAxis" type="{http://www.opengis.net/gml}LengthType"/>
         <element name="rotation" type="{http://www.opengis.net/gml}AngleType"/>
       </sequence>
     </extension>
   </complexContent>
 </complexType>
 
 
 @XmlType(name = "EllipseType", propOrder = {
     "pos",
     "majorAxis",
     "minorAxis",
     "rotation"
 })
 public class EllipseType
     implements CloneableCopyToEqualsHashCodeMergeFromToString
 {
 
     @XmlElement(namespace = "http://www.opengis.net/gml", required = true)
     protected DirectPositionType pos;
     @XmlElement(required = true)
     protected LengthType majorAxis;
     @XmlElement(required = true)
     protected LengthType minorAxis;
     @XmlElement(required = true)
     protected AngleType rotation;

    
Gets the value of the pos property.

Returns:
possible object is
 
     public DirectPositionType getPos() {
         return ;
     }

    
Sets the value of the pos property.

Parameters:
value allowed object is
    public void setPos(DirectPositionType value) {
        this. = value;
    }

    
Gets the value of the majorAxis property.

Returns:
possible object is
    public LengthType getMajorAxis() {
        return ;
    }

    
Sets the value of the majorAxis property.

Parameters:
value allowed object is
    public void setMajorAxis(LengthType value) {
        this. = value;
    }

    
Gets the value of the minorAxis property.

Returns:
possible object is
    public LengthType getMinorAxis() {
        return ;
    }

    
Sets the value of the minorAxis property.

Parameters:
value allowed object is
    public void setMinorAxis(LengthType value) {
        this. = value;
    }

    
Gets the value of the rotation property.

Returns:
possible object is
    public AngleType getRotation() {
        return ;
    }

    
Sets the value of the rotation property.

Parameters:
value allowed object is
    public void setRotation(AngleType value) {
        this. = value;
    }
    public String toString() {
        final ToStringStrategy strategy = .;
        final StringBuilder buffer = new StringBuilder();
        append(nullbufferstrategy);
        return buffer.toString();
    }
    public StringBuilder append(ObjectLocator locatorStringBuilder bufferToStringStrategy strategy) {
        strategy.appendStart(locatorthisbuffer);
        appendFields(locatorbufferstrategy);
        strategy.appendEnd(locatorthisbuffer);
        return buffer;
    }
    public StringBuilder appendFields(ObjectLocator locatorStringBuilder bufferToStringStrategy strategy) {
        super.appendFields(locatorbufferstrategy);
        {
            DirectPositionType thePos;
            thePos = this.getPos();
            strategy.appendField(locatorthis"pos"bufferthePos);
        }
        {
            LengthType theMajorAxis;
            theMajorAxis = this.getMajorAxis();
            strategy.appendField(locatorthis"majorAxis"buffertheMajorAxis);
        }
        {
            LengthType theMinorAxis;
            theMinorAxis = this.getMinorAxis();
            strategy.appendField(locatorthis"minorAxis"buffertheMinorAxis);
        }
        {
            AngleType theRotation;
            theRotation = this.getRotation();
            strategy.appendField(locatorthis"rotation"buffertheRotation);
        }
        return buffer;
    }
    public boolean equals(ObjectLocator thisLocatorObjectLocator thatLocatorObject objectEqualsStrategy strategy) {
        if (!(object instanceof EllipseType)) {
            return false;
        }
        if (this == object) {
            return true;
        }
        if (!super.equals(thisLocatorthatLocatorobjectstrategy)) {
            return false;
        }
        final EllipseType that = ((EllipseTypeobject);
        {
            DirectPositionType lhsPos;
            lhsPos = this.getPos();
            DirectPositionType rhsPos;
            rhsPos = that.getPos();
            if (!strategy.equals(LocatorUtils.property(thisLocator"pos"lhsPos), LocatorUtils.property(thatLocator"pos"rhsPos), lhsPosrhsPos)) {
                return false;
            }
        }
        {
            LengthType lhsMajorAxis;
            lhsMajorAxis = this.getMajorAxis();
            LengthType rhsMajorAxis;
            rhsMajorAxis = that.getMajorAxis();
            if (!strategy.equals(LocatorUtils.property(thisLocator"majorAxis"lhsMajorAxis), LocatorUtils.property(thatLocator"majorAxis"rhsMajorAxis), lhsMajorAxisrhsMajorAxis)) {
                return false;
            }
        }
        {
            LengthType lhsMinorAxis;
            lhsMinorAxis = this.getMinorAxis();
            LengthType rhsMinorAxis;
            rhsMinorAxis = that.getMinorAxis();
            if (!strategy.equals(LocatorUtils.property(thisLocator"minorAxis"lhsMinorAxis), LocatorUtils.property(thatLocator"minorAxis"rhsMinorAxis), lhsMinorAxisrhsMinorAxis)) {
                return false;
            }
        }
        {
            AngleType lhsRotation;
            lhsRotation = this.getRotation();
            AngleType rhsRotation;
            rhsRotation = that.getRotation();
            if (!strategy.equals(LocatorUtils.property(thisLocator"rotation"lhsRotation), LocatorUtils.property(thatLocator"rotation"rhsRotation), lhsRotationrhsRotation)) {
                return false;
            }
        }
        return true;
    }
    public boolean equals(Object object) {
        final EqualsStrategy strategy = .;
        return equals(nullnullobjectstrategy);
    }
    public int hashCode(ObjectLocator locatorHashCodeStrategy strategy) {
        int currentHashCode = super.hashCode(locatorstrategy);
        {
            DirectPositionType thePos;
            thePos = this.getPos();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"pos"thePos), currentHashCodethePos);
        }
        {
            LengthType theMajorAxis;
            theMajorAxis = this.getMajorAxis();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"majorAxis"theMajorAxis), currentHashCodetheMajorAxis);
        }
        {
            LengthType theMinorAxis;
            theMinorAxis = this.getMinorAxis();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"minorAxis"theMinorAxis), currentHashCodetheMinorAxis);
        }
        {
            AngleType theRotation;
            theRotation = this.getRotation();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"rotation"theRotation), currentHashCodetheRotation);
        }
        return currentHashCode;
    }
    public int hashCode() {
        final HashCodeStrategy strategy = .;
        return this.hashCode(nullstrategy);
    }
    public Object clone() {
        return copyTo(createNewInstance());
    }
    public Object copyTo(Object target) {
        final CopyStrategy strategy = .;
        return copyTo(nulltargetstrategy);
    }
    public Object copyTo(ObjectLocator locatorObject targetCopyStrategy strategy) {
        final Object draftCopy = ((target == null)?createNewInstance():target);
        super.copyTo(locatordraftCopystrategy);
        if (draftCopy instanceof EllipseType) {
            final EllipseType copy = ((EllipseTypedraftCopy);
            if (this.!= null) {
                DirectPositionType sourcePos;
                sourcePos = this.getPos();
                DirectPositionType copyPos = ((DirectPositionTypestrategy.copy(LocatorUtils.property(locator"pos"sourcePos), sourcePos));
                copy.setPos(copyPos);
            } else {
                copy.pos = null;
            }
            if (this.!= null) {
                LengthType sourceMajorAxis;
                sourceMajorAxis = this.getMajorAxis();
                LengthType copyMajorAxis = ((LengthTypestrategy.copy(LocatorUtils.property(locator"majorAxis"sourceMajorAxis), sourceMajorAxis));
                copy.setMajorAxis(copyMajorAxis);
            } else {
                copy.majorAxis = null;
            }
            if (this.!= null) {
                LengthType sourceMinorAxis;
                sourceMinorAxis = this.getMinorAxis();
                LengthType copyMinorAxis = ((LengthTypestrategy.copy(LocatorUtils.property(locator"minorAxis"sourceMinorAxis), sourceMinorAxis));
                copy.setMinorAxis(copyMinorAxis);
            } else {
                copy.minorAxis = null;
            }
            if (this.!= null) {
                AngleType sourceRotation;
                sourceRotation = this.getRotation();
                AngleType copyRotation = ((AngleTypestrategy.copy(LocatorUtils.property(locator"rotation"sourceRotation), sourceRotation));
                copy.setRotation(copyRotation);
            } else {
                copy.rotation = null;
            }
        }
        return draftCopy;
    }
    public Object createNewInstance() {
        return new EllipseType();
    }
    public void mergeFrom(Object leftObject right) {
        final MergeStrategy strategy = .;
        mergeFrom(nullnullleftrightstrategy);
    }
    public void mergeFrom(ObjectLocator leftLocatorObjectLocator rightLocatorObject leftObject rightMergeStrategy strategy) {
        super.mergeFrom(leftLocatorrightLocatorleftrightstrategy);
        if (right instanceof EllipseType) {
            final EllipseType target = this;
            final EllipseType leftObject = ((EllipseTypeleft);
            final EllipseType rightObject = ((EllipseTyperight);
            {
                DirectPositionType lhsPos;
                lhsPos = leftObject.getPos();
                DirectPositionType rhsPos;
                rhsPos = rightObject.getPos();
                target.setPos(((DirectPositionTypestrategy.merge(LocatorUtils.property(leftLocator"pos"lhsPos), LocatorUtils.property(rightLocator"pos"rhsPos), lhsPosrhsPos)));
            }
            {
                LengthType lhsMajorAxis;
                lhsMajorAxis = leftObject.getMajorAxis();
                LengthType rhsMajorAxis;
                rhsMajorAxis = rightObject.getMajorAxis();
                target.setMajorAxis(((LengthTypestrategy.merge(LocatorUtils.property(leftLocator"majorAxis"lhsMajorAxis), LocatorUtils.property(rightLocator"majorAxis"rhsMajorAxis), lhsMajorAxisrhsMajorAxis)));
            }
            {
                LengthType lhsMinorAxis;
                lhsMinorAxis = leftObject.getMinorAxis();
                LengthType rhsMinorAxis;
                rhsMinorAxis = rightObject.getMinorAxis();
                target.setMinorAxis(((LengthTypestrategy.merge(LocatorUtils.property(leftLocator"minorAxis"lhsMinorAxis), LocatorUtils.property(rightLocator"minorAxis"rhsMinorAxis), lhsMinorAxisrhsMinorAxis)));
            }
            {
                AngleType lhsRotation;
                lhsRotation = leftObject.getRotation();
                AngleType rhsRotation;
                rhsRotation = rightObject.getRotation();
                target.setRotation(((AngleTypestrategy.merge(LocatorUtils.property(leftLocator"rotation"lhsRotation), LocatorUtils.property(rightLocator"rotation"rhsRotation), lhsRotationrhsRotation)));
            }
        }
    }
New to GrepCode? Check out our FAQ X