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: 2011.02.20 at 01:29:24 PM MEZ 
  //
  
  
  package net.opengis.xls.v_1_1_0;
 

Java class for PositionType complex type.

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

 <complexType name="PositionType">
   <complexContent>
     <extension base="{http://www.opengis.net/xls}AbstractPositionType">
       <sequence>
         <element ref="{http://www.opengis.net/gml}Point"/>
         <choice minOccurs="0">
           <element ref="{http://www.opengis.net/xls}Ellipse"/>
           <element ref="{http://www.opengis.net/gml}CircleByCenterPoint"/>
           <element ref="{http://www.opengis.net/xls}CircularArc"/>
           <element ref="{http://www.opengis.net/gml}Polygon"/>
           <element ref="{http://www.opengis.net/gml}MultiPolygon"/>
         </choice>
         <element name="QoP" type="{http://www.opengis.net/xls}QualityOfPositionType" minOccurs="0"/>
         <element ref="{http://www.opengis.net/xls}Time" minOccurs="0"/>
         <element name="Speed" type="{http://www.opengis.net/xls}SpeedType" minOccurs="0"/>
         <element name="Direction" type="{http://www.opengis.net/xls}AngleType" minOccurs="0"/>
       </sequence>
       <attribute name="levelOfConf" type="{http://www.w3.org/2001/XMLSchema}string" />
     </extension>
   </complexContent>
 </complexType>
 
 
 @XmlType(name = "PositionType", propOrder = {
     "point",
     "ellipse",
     "circleByCenterPoint",
     "circularArc",
     "polygon",
     "multiPolygon",
     "qoP",
     "time",
     "speed",
     "direction"
 })
 public class PositionType
     extends AbstractPositionType
     implements CloneableCopyToEqualsHashCodeMergeFromToString
 {
 
     @XmlElement(name = "Point", namespace = "http://www.opengis.net/gml", required = true)
     protected PointType point;
     @XmlElement(name = "Ellipse")
     protected EllipseType ellipse;
     @XmlElement(name = "CircleByCenterPoint", namespace = "http://www.opengis.net/gml")
     @XmlElement(name = "CircularArc")
     protected CircularArcType circularArc;
     @XmlElement(name = "Polygon", namespace = "http://www.opengis.net/gml")
     protected PolygonType polygon;
     @XmlElement(name = "MultiPolygon", namespace = "http://www.opengis.net/gml")
     protected MultiPolygonType multiPolygon;
    @XmlElement(name = "QoP")
    protected QualityOfPositionType qoP;
    @XmlElement(name = "Time")
    protected TimeType time;
    @XmlElement(name = "Speed")
    protected SpeedType speed;
    @XmlElement(name = "Direction")
    protected AngleType direction;
    @XmlAttribute(name = "levelOfConf")
    protected String levelOfConf;

    
Gets the value of the point property.

Returns:
possible object is
    public PointType getPoint() {
        return ;
    }

    
Sets the value of the point property.

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

    
Gets the value of the ellipse property.

Returns:
possible object is
    public EllipseType getEllipse() {
        return ;
    }

    
Sets the value of the ellipse property.

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

    
Gets the value of the circleByCenterPoint property.

Returns:
possible object is
        return ;
    }

    
Sets the value of the circleByCenterPoint property.

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

    
Gets the value of the circularArc property.

Returns:
possible object is
    public CircularArcType getCircularArc() {
        return ;
    }

    
Sets the value of the circularArc property.

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

    
Gets the value of the polygon property.

Returns:
possible object is
    public PolygonType getPolygon() {
        return ;
    }

    
Sets the value of the polygon property.

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

    
Gets the value of the multiPolygon property.

Returns:
possible object is
    public MultiPolygonType getMultiPolygon() {
        return ;
    }

    
Sets the value of the multiPolygon property.

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

    
Gets the value of the qoP property.

Returns:
possible object is
    public QualityOfPositionType getQoP() {
        return ;
    }

    
Sets the value of the qoP property.

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

    
Gets the value of the time property.

Returns:
possible object is
    public TimeType getTime() {
        return ;
    }

    
Sets the value of the time property.

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

    
Gets the value of the speed property.

Returns:
possible object is
    public SpeedType getSpeed() {
        return ;
    }

    
Sets the value of the speed property.

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

    
Gets the value of the direction property.

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

    
Sets the value of the direction property.

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

    
Gets the value of the levelOfConf property.

Returns:
possible object is
    public String getLevelOfConf() {
        return ;
    }

    
Sets the value of the levelOfConf property.

Parameters:
value allowed object is
    public void setLevelOfConf(String 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);
        {
            PointType thePoint;
            thePoint = this.getPoint();
            strategy.appendField(locatorthis"point"bufferthePoint);
        }
        {
            EllipseType theEllipse;
            theEllipse = this.getEllipse();
            strategy.appendField(locatorthis"ellipse"buffertheEllipse);
        }
        {
            CircleByCenterPointType theCircleByCenterPoint;
            theCircleByCenterPoint = this.getCircleByCenterPoint();
            strategy.appendField(locatorthis"circleByCenterPoint"buffertheCircleByCenterPoint);
        }
        {
            CircularArcType theCircularArc;
            theCircularArc = this.getCircularArc();
            strategy.appendField(locatorthis"circularArc"buffertheCircularArc);
        }
        {
            PolygonType thePolygon;
            thePolygon = this.getPolygon();
            strategy.appendField(locatorthis"polygon"bufferthePolygon);
        }
        {
            MultiPolygonType theMultiPolygon;
            theMultiPolygon = this.getMultiPolygon();
            strategy.appendField(locatorthis"multiPolygon"buffertheMultiPolygon);
        }
        {
            QualityOfPositionType theQoP;
            theQoP = this.getQoP();
            strategy.appendField(locatorthis"qoP"buffertheQoP);
        }
        {
            TimeType theTime;
            theTime = this.getTime();
            strategy.appendField(locatorthis"time"buffertheTime);
        }
        {
            SpeedType theSpeed;
            theSpeed = this.getSpeed();
            strategy.appendField(locatorthis"speed"buffertheSpeed);
        }
        {
            AngleType theDirection;
            theDirection = this.getDirection();
            strategy.appendField(locatorthis"direction"buffertheDirection);
        }
        {
            String theLevelOfConf;
            theLevelOfConf = this.getLevelOfConf();
            strategy.appendField(locatorthis"levelOfConf"buffertheLevelOfConf);
        }
        return buffer;
    }
    public boolean equals(ObjectLocator thisLocatorObjectLocator thatLocatorObject objectEqualsStrategy strategy) {
        if (!(object instanceof PositionType)) {
            return false;
        }
        if (this == object) {
            return true;
        }
        if (!super.equals(thisLocatorthatLocatorobjectstrategy)) {
            return false;
        }
        final PositionType that = ((PositionTypeobject);
        {
            PointType lhsPoint;
            lhsPoint = this.getPoint();
            PointType rhsPoint;
            rhsPoint = that.getPoint();
            if (!strategy.equals(LocatorUtils.property(thisLocator"point"lhsPoint), LocatorUtils.property(thatLocator"point"rhsPoint), lhsPointrhsPoint)) {
                return false;
            }
        }
        {
            EllipseType lhsEllipse;
            lhsEllipse = this.getEllipse();
            EllipseType rhsEllipse;
            rhsEllipse = that.getEllipse();
            if (!strategy.equals(LocatorUtils.property(thisLocator"ellipse"lhsEllipse), LocatorUtils.property(thatLocator"ellipse"rhsEllipse), lhsEllipserhsEllipse)) {
                return false;
            }
        }
        {
            CircleByCenterPointType lhsCircleByCenterPoint;
            lhsCircleByCenterPoint = this.getCircleByCenterPoint();
            CircleByCenterPointType rhsCircleByCenterPoint;
            rhsCircleByCenterPoint = that.getCircleByCenterPoint();
            if (!strategy.equals(LocatorUtils.property(thisLocator"circleByCenterPoint"lhsCircleByCenterPoint), LocatorUtils.property(thatLocator"circleByCenterPoint"rhsCircleByCenterPoint), lhsCircleByCenterPointrhsCircleByCenterPoint)) {
                return false;
            }
        }
        {
            CircularArcType lhsCircularArc;
            lhsCircularArc = this.getCircularArc();
            CircularArcType rhsCircularArc;
            rhsCircularArc = that.getCircularArc();
            if (!strategy.equals(LocatorUtils.property(thisLocator"circularArc"lhsCircularArc), LocatorUtils.property(thatLocator"circularArc"rhsCircularArc), lhsCircularArcrhsCircularArc)) {
                return false;
            }
        }
        {
            PolygonType lhsPolygon;
            lhsPolygon = this.getPolygon();
            PolygonType rhsPolygon;
            rhsPolygon = that.getPolygon();
            if (!strategy.equals(LocatorUtils.property(thisLocator"polygon"lhsPolygon), LocatorUtils.property(thatLocator"polygon"rhsPolygon), lhsPolygonrhsPolygon)) {
                return false;
            }
        }
        {
            MultiPolygonType lhsMultiPolygon;
            lhsMultiPolygon = this.getMultiPolygon();
            MultiPolygonType rhsMultiPolygon;
            rhsMultiPolygon = that.getMultiPolygon();
            if (!strategy.equals(LocatorUtils.property(thisLocator"multiPolygon"lhsMultiPolygon), LocatorUtils.property(thatLocator"multiPolygon"rhsMultiPolygon), lhsMultiPolygonrhsMultiPolygon)) {
                return false;
            }
        }
        {
            QualityOfPositionType lhsQoP;
            lhsQoP = this.getQoP();
            QualityOfPositionType rhsQoP;
            rhsQoP = that.getQoP();
            if (!strategy.equals(LocatorUtils.property(thisLocator"qoP"lhsQoP), LocatorUtils.property(thatLocator"qoP"rhsQoP), lhsQoPrhsQoP)) {
                return false;
            }
        }
        {
            TimeType lhsTime;
            lhsTime = this.getTime();
            TimeType rhsTime;
            rhsTime = that.getTime();
            if (!strategy.equals(LocatorUtils.property(thisLocator"time"lhsTime), LocatorUtils.property(thatLocator"time"rhsTime), lhsTimerhsTime)) {
                return false;
            }
        }
        {
            SpeedType lhsSpeed;
            lhsSpeed = this.getSpeed();
            SpeedType rhsSpeed;
            rhsSpeed = that.getSpeed();
            if (!strategy.equals(LocatorUtils.property(thisLocator"speed"lhsSpeed), LocatorUtils.property(thatLocator"speed"rhsSpeed), lhsSpeedrhsSpeed)) {
                return false;
            }
        }
        {
            AngleType lhsDirection;
            lhsDirection = this.getDirection();
            AngleType rhsDirection;
            rhsDirection = that.getDirection();
            if (!strategy.equals(LocatorUtils.property(thisLocator"direction"lhsDirection), LocatorUtils.property(thatLocator"direction"rhsDirection), lhsDirectionrhsDirection)) {
                return false;
            }
        }
        {
            String lhsLevelOfConf;
            lhsLevelOfConf = this.getLevelOfConf();
            String rhsLevelOfConf;
            rhsLevelOfConf = that.getLevelOfConf();
            if (!strategy.equals(LocatorUtils.property(thisLocator"levelOfConf"lhsLevelOfConf), LocatorUtils.property(thatLocator"levelOfConf"rhsLevelOfConf), lhsLevelOfConfrhsLevelOfConf)) {
                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);
        {
            PointType thePoint;
            thePoint = this.getPoint();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"point"thePoint), currentHashCodethePoint);
        }
        {
            EllipseType theEllipse;
            theEllipse = this.getEllipse();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"ellipse"theEllipse), currentHashCodetheEllipse);
        }
        {
            CircleByCenterPointType theCircleByCenterPoint;
            theCircleByCenterPoint = this.getCircleByCenterPoint();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"circleByCenterPoint"theCircleByCenterPoint), currentHashCodetheCircleByCenterPoint);
        }
        {
            CircularArcType theCircularArc;
            theCircularArc = this.getCircularArc();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"circularArc"theCircularArc), currentHashCodetheCircularArc);
        }
        {
            PolygonType thePolygon;
            thePolygon = this.getPolygon();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"polygon"thePolygon), currentHashCodethePolygon);
        }
        {
            MultiPolygonType theMultiPolygon;
            theMultiPolygon = this.getMultiPolygon();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"multiPolygon"theMultiPolygon), currentHashCodetheMultiPolygon);
        }
        {
            QualityOfPositionType theQoP;
            theQoP = this.getQoP();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"qoP"theQoP), currentHashCodetheQoP);
        }
        {
            TimeType theTime;
            theTime = this.getTime();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"time"theTime), currentHashCodetheTime);
        }
        {
            SpeedType theSpeed;
            theSpeed = this.getSpeed();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"speed"theSpeed), currentHashCodetheSpeed);
        }
        {
            AngleType theDirection;
            theDirection = this.getDirection();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"direction"theDirection), currentHashCodetheDirection);
        }
        {
            String theLevelOfConf;
            theLevelOfConf = this.getLevelOfConf();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"levelOfConf"theLevelOfConf), currentHashCodetheLevelOfConf);
        }
        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 PositionType) {
            final PositionType copy = ((PositionTypedraftCopy);
            if (this.!= null) {
                PointType sourcePoint;
                sourcePoint = this.getPoint();
                PointType copyPoint = ((PointTypestrategy.copy(LocatorUtils.property(locator"point"sourcePoint), sourcePoint));
                copy.setPoint(copyPoint);
            } else {
                copy.point = null;
            }
            if (this.!= null) {
                EllipseType sourceEllipse;
                sourceEllipse = this.getEllipse();
                EllipseType copyEllipse = ((EllipseTypestrategy.copy(LocatorUtils.property(locator"ellipse"sourceEllipse), sourceEllipse));
                copy.setEllipse(copyEllipse);
            } else {
                copy.ellipse = null;
            }
            if (this.!= null) {
                CircleByCenterPointType sourceCircleByCenterPoint;
                sourceCircleByCenterPoint = this.getCircleByCenterPoint();
                CircleByCenterPointType copyCircleByCenterPoint = ((CircleByCenterPointTypestrategy.copy(LocatorUtils.property(locator"circleByCenterPoint"sourceCircleByCenterPoint), sourceCircleByCenterPoint));
                copy.setCircleByCenterPoint(copyCircleByCenterPoint);
            } else {
                copy.circleByCenterPoint = null;
            }
            if (this.!= null) {
                CircularArcType sourceCircularArc;
                sourceCircularArc = this.getCircularArc();
                CircularArcType copyCircularArc = ((CircularArcTypestrategy.copy(LocatorUtils.property(locator"circularArc"sourceCircularArc), sourceCircularArc));
                copy.setCircularArc(copyCircularArc);
            } else {
                copy.circularArc = null;
            }
            if (this.!= null) {
                PolygonType sourcePolygon;
                sourcePolygon = this.getPolygon();
                PolygonType copyPolygon = ((PolygonTypestrategy.copy(LocatorUtils.property(locator"polygon"sourcePolygon), sourcePolygon));
                copy.setPolygon(copyPolygon);
            } else {
                copy.polygon = null;
            }
            if (this.!= null) {
                MultiPolygonType sourceMultiPolygon;
                sourceMultiPolygon = this.getMultiPolygon();
                MultiPolygonType copyMultiPolygon = ((MultiPolygonTypestrategy.copy(LocatorUtils.property(locator"multiPolygon"sourceMultiPolygon), sourceMultiPolygon));
                copy.setMultiPolygon(copyMultiPolygon);
            } else {
                copy.multiPolygon = null;
            }
            if (this.!= null) {
                QualityOfPositionType sourceQoP;
                sourceQoP = this.getQoP();
                QualityOfPositionType copyQoP = ((QualityOfPositionTypestrategy.copy(LocatorUtils.property(locator"qoP"sourceQoP), sourceQoP));
                copy.setQoP(copyQoP);
            } else {
                copy.qoP = null;
            }
            if (this.!= null) {
                TimeType sourceTime;
                sourceTime = this.getTime();
                TimeType copyTime = ((TimeTypestrategy.copy(LocatorUtils.property(locator"time"sourceTime), sourceTime));
                copy.setTime(copyTime);
            } else {
                copy.time = null;
            }
            if (this.!= null) {
                SpeedType sourceSpeed;
                sourceSpeed = this.getSpeed();
                SpeedType copySpeed = ((SpeedTypestrategy.copy(LocatorUtils.property(locator"speed"sourceSpeed), sourceSpeed));
                copy.setSpeed(copySpeed);
            } else {
                copy.speed = null;
            }
            if (this.!= null) {
                AngleType sourceDirection;
                sourceDirection = this.getDirection();
                AngleType copyDirection = ((AngleTypestrategy.copy(LocatorUtils.property(locator"direction"sourceDirection), sourceDirection));
                copy.setDirection(copyDirection);
            } else {
                copy.direction = null;
            }
            if (this.!= null) {
                String sourceLevelOfConf;
                sourceLevelOfConf = this.getLevelOfConf();
                String copyLevelOfConf = ((Stringstrategy.copy(LocatorUtils.property(locator"levelOfConf"sourceLevelOfConf), sourceLevelOfConf));
                copy.setLevelOfConf(copyLevelOfConf);
            } else {
                copy.levelOfConf = null;
            }
        }
        return draftCopy;
    }
    public Object createNewInstance() {
        return new PositionType();
    }
    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 PositionType) {
            final PositionType target = this;
            final PositionType leftObject = ((PositionTypeleft);
            final PositionType rightObject = ((PositionTyperight);
            {
                PointType lhsPoint;
                lhsPoint = leftObject.getPoint();
                PointType rhsPoint;
                rhsPoint = rightObject.getPoint();
                target.setPoint(((PointTypestrategy.merge(LocatorUtils.property(leftLocator"point"lhsPoint), LocatorUtils.property(rightLocator"point"rhsPoint), lhsPointrhsPoint)));
            }
            {
                EllipseType lhsEllipse;
                lhsEllipse = leftObject.getEllipse();
                EllipseType rhsEllipse;
                rhsEllipse = rightObject.getEllipse();
                target.setEllipse(((EllipseTypestrategy.merge(LocatorUtils.property(leftLocator"ellipse"lhsEllipse), LocatorUtils.property(rightLocator"ellipse"rhsEllipse), lhsEllipserhsEllipse)));
            }
            {
                CircleByCenterPointType lhsCircleByCenterPoint;
                lhsCircleByCenterPoint = leftObject.getCircleByCenterPoint();
                CircleByCenterPointType rhsCircleByCenterPoint;
                rhsCircleByCenterPoint = rightObject.getCircleByCenterPoint();
                target.setCircleByCenterPoint(((CircleByCenterPointTypestrategy.merge(LocatorUtils.property(leftLocator"circleByCenterPoint"lhsCircleByCenterPoint), LocatorUtils.property(rightLocator"circleByCenterPoint"rhsCircleByCenterPoint), lhsCircleByCenterPointrhsCircleByCenterPoint)));
            }
            {
                CircularArcType lhsCircularArc;
                lhsCircularArc = leftObject.getCircularArc();
                CircularArcType rhsCircularArc;
                rhsCircularArc = rightObject.getCircularArc();
                target.setCircularArc(((CircularArcTypestrategy.merge(LocatorUtils.property(leftLocator"circularArc"lhsCircularArc), LocatorUtils.property(rightLocator"circularArc"rhsCircularArc), lhsCircularArcrhsCircularArc)));
            }
            {
                PolygonType lhsPolygon;
                lhsPolygon = leftObject.getPolygon();
                PolygonType rhsPolygon;
                rhsPolygon = rightObject.getPolygon();
                target.setPolygon(((PolygonTypestrategy.merge(LocatorUtils.property(leftLocator"polygon"lhsPolygon), LocatorUtils.property(rightLocator"polygon"rhsPolygon), lhsPolygonrhsPolygon)));
            }
            {
                MultiPolygonType lhsMultiPolygon;
                lhsMultiPolygon = leftObject.getMultiPolygon();
                MultiPolygonType rhsMultiPolygon;
                rhsMultiPolygon = rightObject.getMultiPolygon();
                target.setMultiPolygon(((MultiPolygonTypestrategy.merge(LocatorUtils.property(leftLocator"multiPolygon"lhsMultiPolygon), LocatorUtils.property(rightLocator"multiPolygon"rhsMultiPolygon), lhsMultiPolygonrhsMultiPolygon)));
            }
            {
                QualityOfPositionType lhsQoP;
                lhsQoP = leftObject.getQoP();
                QualityOfPositionType rhsQoP;
                rhsQoP = rightObject.getQoP();
                target.setQoP(((QualityOfPositionTypestrategy.merge(LocatorUtils.property(leftLocator"qoP"lhsQoP), LocatorUtils.property(rightLocator"qoP"rhsQoP), lhsQoPrhsQoP)));
            }
            {
                TimeType lhsTime;
                lhsTime = leftObject.getTime();
                TimeType rhsTime;
                rhsTime = rightObject.getTime();
                target.setTime(((TimeTypestrategy.merge(LocatorUtils.property(leftLocator"time"lhsTime), LocatorUtils.property(rightLocator"time"rhsTime), lhsTimerhsTime)));
            }
            {
                SpeedType lhsSpeed;
                lhsSpeed = leftObject.getSpeed();
                SpeedType rhsSpeed;
                rhsSpeed = rightObject.getSpeed();
                target.setSpeed(((SpeedTypestrategy.merge(LocatorUtils.property(leftLocator"speed"lhsSpeed), LocatorUtils.property(rightLocator"speed"rhsSpeed), lhsSpeedrhsSpeed)));
            }
            {
                AngleType lhsDirection;
                lhsDirection = leftObject.getDirection();
                AngleType rhsDirection;
                rhsDirection = rightObject.getDirection();
                target.setDirection(((AngleTypestrategy.merge(LocatorUtils.property(leftLocator"direction"lhsDirection), LocatorUtils.property(rightLocator"direction"rhsDirection), lhsDirectionrhsDirection)));
            }
            {
                String lhsLevelOfConf;
                lhsLevelOfConf = leftObject.getLevelOfConf();
                String rhsLevelOfConf;
                rhsLevelOfConf = rightObject.getLevelOfConf();
                target.setLevelOfConf(((Stringstrategy.merge(LocatorUtils.property(leftLocator"levelOfConf"lhsLevelOfConf), LocatorUtils.property(rightLocator"levelOfConf"rhsLevelOfConf), lhsLevelOfConfrhsLevelOfConf)));
            }
        }
    }
New to GrepCode? Check out our FAQ X