Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  //
  // Diese Datei wurde mit der JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.6 generiert 
  // Siehe <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
  // Änderungen an dieser Datei gehen bei einer Neukompilierung des Quellschemas verloren. 
  // Generiert: 2013.01.31 um 01:29:25 AM CET 
  //
  
  
  package net.opengis.xls.v_1_1_0;
 
 import java.util.List;
Defines the Determine Route response parameters.

Java-Klasse für DetermineRouteResponseType complex type.

Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist.

 <complexType name="DetermineRouteResponseType">
   <complexContent>
     <extension base="{http://www.opengis.net/xls}AbstractResponseParametersType">
       <sequence>
         <element ref="{http://www.opengis.net/xls}RouteHandle" minOccurs="0"/>
         <element ref="{http://www.opengis.net/xls}RouteSummary"/>
         <element ref="{http://www.opengis.net/xls}RouteGeometry" minOccurs="0"/>
         <element ref="{http://www.opengis.net/xls}RouteInstructionsList" minOccurs="0"/>
         <element ref="{http://www.opengis.net/xls}RouteMap" maxOccurs="unbounded" minOccurs="0"/>
       </sequence>
     </extension>
   </complexContent>
 </complexType>
 
 
 @XmlType(name = "DetermineRouteResponseType", propOrder = {
     "routeHandle",
     "routeSummary",
     "routeGeometry",
     "routeInstructionsList",
     "routeMap"
 })
     implements CloneableCopyToEqualsHashCodeMergeFromToString
 {
 
     @XmlElement(name = "RouteHandle")
     protected RouteHandleType routeHandle;
     @XmlElement(name = "RouteSummary", required = true)
     protected RouteSummaryType routeSummary;
     @XmlElement(name = "RouteGeometry")
     protected RouteGeometryType routeGeometry;
     @XmlElement(name = "RouteInstructionsList")
     @XmlElement(name = "RouteMap")
     protected List<RouteMapTyperouteMap;

    
Reference to the route stored at the Route Determination Service server.

Returns:
possible object is
 
     public RouteHandleType getRouteHandle() {
         return ;
     }

    
Legt den Wert der routeHandle-Eigenschaft fest.

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

    
Response for requested route summary.

Returns:
possible object is
    public RouteSummaryType getRouteSummary() {
        return ;
    }

    
Legt den Wert der routeSummary-Eigenschaft fest.

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

    
Response for requested route geometry.

Returns:
possible object is
        return ;
    }

    
Legt den Wert der routeGeometry-Eigenschaft fest.

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

    
Response for requested route instructions.

Returns:
possible object is
        return ;
    }

    
Legt den Wert der routeInstructionsList-Eigenschaft fest.

Parameters:
value allowed object is
        this. = value;
    }

    
Response list for requested route maps.Gets the value of the routeMap property.

This accessor method returns a reference to the live list, not a snapshot. Therefore any modification you make to the returned list will be present inside the JAXB object. This is why there is not a set method for the routeMap property.

For example, to add a new item, do as follows:

    getRouteMap().add(newItem);
 

Objects of the following type(s) are allowed in the list

    public List<RouteMapTypegetRouteMap() {
        if ( == null) {
             = new ArrayList<RouteMapType>();
        }
        return this.;
    }
    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);
        {
            RouteHandleType theRouteHandle;
            theRouteHandle = this.getRouteHandle();
            strategy.appendField(locatorthis"routeHandle"buffertheRouteHandle);
        }
        {
            RouteSummaryType theRouteSummary;
            theRouteSummary = this.getRouteSummary();
            strategy.appendField(locatorthis"routeSummary"buffertheRouteSummary);
        }
        {
            RouteGeometryType theRouteGeometry;
            theRouteGeometry = this.getRouteGeometry();
            strategy.appendField(locatorthis"routeGeometry"buffertheRouteGeometry);
        }
        {
            RouteInstructionsListType theRouteInstructionsList;
            theRouteInstructionsList = this.getRouteInstructionsList();
            strategy.appendField(locatorthis"routeInstructionsList"buffertheRouteInstructionsList);
        }
        {
            List<RouteMapTypetheRouteMap;
            theRouteMap = this.getRouteMap();
            strategy.appendField(locatorthis"routeMap"buffertheRouteMap);
        }
        return buffer;
    }
    public boolean equals(ObjectLocator thisLocatorObjectLocator thatLocatorObject objectEqualsStrategy strategy) {
        if (!(object instanceof DetermineRouteResponseType)) {
            return false;
        }
        if (this == object) {
            return true;
        }
        if (!super.equals(thisLocatorthatLocatorobjectstrategy)) {
            return false;
        }
        final DetermineRouteResponseType that = ((DetermineRouteResponseTypeobject);
        {
            RouteHandleType lhsRouteHandle;
            lhsRouteHandle = this.getRouteHandle();
            RouteHandleType rhsRouteHandle;
            rhsRouteHandle = that.getRouteHandle();
            if (!strategy.equals(LocatorUtils.property(thisLocator"routeHandle"lhsRouteHandle), LocatorUtils.property(thatLocator"routeHandle"rhsRouteHandle), lhsRouteHandlerhsRouteHandle)) {
                return false;
            }
        }
        {
            RouteSummaryType lhsRouteSummary;
            lhsRouteSummary = this.getRouteSummary();
            RouteSummaryType rhsRouteSummary;
            rhsRouteSummary = that.getRouteSummary();
            if (!strategy.equals(LocatorUtils.property(thisLocator"routeSummary"lhsRouteSummary), LocatorUtils.property(thatLocator"routeSummary"rhsRouteSummary), lhsRouteSummaryrhsRouteSummary)) {
                return false;
            }
        }
        {
            RouteGeometryType lhsRouteGeometry;
            lhsRouteGeometry = this.getRouteGeometry();
            RouteGeometryType rhsRouteGeometry;
            rhsRouteGeometry = that.getRouteGeometry();
            if (!strategy.equals(LocatorUtils.property(thisLocator"routeGeometry"lhsRouteGeometry), LocatorUtils.property(thatLocator"routeGeometry"rhsRouteGeometry), lhsRouteGeometryrhsRouteGeometry)) {
                return false;
            }
        }
        {
            RouteInstructionsListType lhsRouteInstructionsList;
            lhsRouteInstructionsList = this.getRouteInstructionsList();
            RouteInstructionsListType rhsRouteInstructionsList;
            rhsRouteInstructionsList = that.getRouteInstructionsList();
            if (!strategy.equals(LocatorUtils.property(thisLocator"routeInstructionsList"lhsRouteInstructionsList), LocatorUtils.property(thatLocator"routeInstructionsList"rhsRouteInstructionsList), lhsRouteInstructionsListrhsRouteInstructionsList)) {
                return false;
            }
        }
        {
            List<RouteMapTypelhsRouteMap;
            lhsRouteMap = this.getRouteMap();
            List<RouteMapTyperhsRouteMap;
            rhsRouteMap = that.getRouteMap();
            if (!strategy.equals(LocatorUtils.property(thisLocator"routeMap"lhsRouteMap), LocatorUtils.property(thatLocator"routeMap"rhsRouteMap), lhsRouteMaprhsRouteMap)) {
                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);
        {
            RouteHandleType theRouteHandle;
            theRouteHandle = this.getRouteHandle();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"routeHandle"theRouteHandle), currentHashCodetheRouteHandle);
        }
        {
            RouteSummaryType theRouteSummary;
            theRouteSummary = this.getRouteSummary();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"routeSummary"theRouteSummary), currentHashCodetheRouteSummary);
        }
        {
            RouteGeometryType theRouteGeometry;
            theRouteGeometry = this.getRouteGeometry();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"routeGeometry"theRouteGeometry), currentHashCodetheRouteGeometry);
        }
        {
            RouteInstructionsListType theRouteInstructionsList;
            theRouteInstructionsList = this.getRouteInstructionsList();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"routeInstructionsList"theRouteInstructionsList), currentHashCodetheRouteInstructionsList);
        }
        {
            List<RouteMapTypetheRouteMap;
            theRouteMap = this.getRouteMap();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"routeMap"theRouteMap), currentHashCodetheRouteMap);
        }
        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 DetermineRouteResponseType) {
            final DetermineRouteResponseType copy = ((DetermineRouteResponseTypedraftCopy);
            if (this.!= null) {
                RouteHandleType sourceRouteHandle;
                sourceRouteHandle = this.getRouteHandle();
                RouteHandleType copyRouteHandle = ((RouteHandleTypestrategy.copy(LocatorUtils.property(locator"routeHandle"sourceRouteHandle), sourceRouteHandle));
                copy.setRouteHandle(copyRouteHandle);
            } else {
                copy.routeHandle = null;
            }
            if (this.!= null) {
                RouteSummaryType sourceRouteSummary;
                sourceRouteSummary = this.getRouteSummary();
                RouteSummaryType copyRouteSummary = ((RouteSummaryTypestrategy.copy(LocatorUtils.property(locator"routeSummary"sourceRouteSummary), sourceRouteSummary));
                copy.setRouteSummary(copyRouteSummary);
            } else {
                copy.routeSummary = null;
            }
            if (this.!= null) {
                RouteGeometryType sourceRouteGeometry;
                sourceRouteGeometry = this.getRouteGeometry();
                RouteGeometryType copyRouteGeometry = ((RouteGeometryTypestrategy.copy(LocatorUtils.property(locator"routeGeometry"sourceRouteGeometry), sourceRouteGeometry));
                copy.setRouteGeometry(copyRouteGeometry);
            } else {
                copy.routeGeometry = null;
            }
            if (this.!= null) {
                RouteInstructionsListType sourceRouteInstructionsList;
                sourceRouteInstructionsList = this.getRouteInstructionsList();
                RouteInstructionsListType copyRouteInstructionsList = ((RouteInstructionsListTypestrategy.copy(LocatorUtils.property(locator"routeInstructionsList"sourceRouteInstructionsList), sourceRouteInstructionsList));
                copy.setRouteInstructionsList(copyRouteInstructionsList);
            } else {
                copy.routeInstructionsList = null;
            }
            if ((this.!= null)&&(!this..isEmpty())) {
                List<RouteMapTypesourceRouteMap;
                sourceRouteMap = this.getRouteMap();
                @SuppressWarnings("unchecked")
                List<RouteMapTypecopyRouteMap = ((List<RouteMapType> ) strategy.copy(LocatorUtils.property(locator"routeMap"sourceRouteMap), sourceRouteMap));
                copy.routeMap = null;
                List<RouteMapTypeuniqueRouteMapl = copy.getRouteMap();
                uniqueRouteMapl.addAll(copyRouteMap);
            } else {
                copy.routeMap = null;
            }
        }
        return draftCopy;
    }
    public Object createNewInstance() {
        return new DetermineRouteResponseType();
    }
    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 DetermineRouteResponseType) {
            final DetermineRouteResponseType target = this;
            final DetermineRouteResponseType leftObject = ((DetermineRouteResponseTypeleft);
            final DetermineRouteResponseType rightObject = ((DetermineRouteResponseTyperight);
            {
                RouteHandleType lhsRouteHandle;
                lhsRouteHandle = leftObject.getRouteHandle();
                RouteHandleType rhsRouteHandle;
                rhsRouteHandle = rightObject.getRouteHandle();
                target.setRouteHandle(((RouteHandleTypestrategy.merge(LocatorUtils.property(leftLocator"routeHandle"lhsRouteHandle), LocatorUtils.property(rightLocator"routeHandle"rhsRouteHandle), lhsRouteHandlerhsRouteHandle)));
            }
            {
                RouteSummaryType lhsRouteSummary;
                lhsRouteSummary = leftObject.getRouteSummary();
                RouteSummaryType rhsRouteSummary;
                rhsRouteSummary = rightObject.getRouteSummary();
                target.setRouteSummary(((RouteSummaryTypestrategy.merge(LocatorUtils.property(leftLocator"routeSummary"lhsRouteSummary), LocatorUtils.property(rightLocator"routeSummary"rhsRouteSummary), lhsRouteSummaryrhsRouteSummary)));
            }
            {
                RouteGeometryType lhsRouteGeometry;
                lhsRouteGeometry = leftObject.getRouteGeometry();
                RouteGeometryType rhsRouteGeometry;
                rhsRouteGeometry = rightObject.getRouteGeometry();
                target.setRouteGeometry(((RouteGeometryTypestrategy.merge(LocatorUtils.property(leftLocator"routeGeometry"lhsRouteGeometry), LocatorUtils.property(rightLocator"routeGeometry"rhsRouteGeometry), lhsRouteGeometryrhsRouteGeometry)));
            }
            {
                RouteInstructionsListType lhsRouteInstructionsList;
                lhsRouteInstructionsList = leftObject.getRouteInstructionsList();
                RouteInstructionsListType rhsRouteInstructionsList;
                rhsRouteInstructionsList = rightObject.getRouteInstructionsList();
                target.setRouteInstructionsList(((RouteInstructionsListTypestrategy.merge(LocatorUtils.property(leftLocator"routeInstructionsList"lhsRouteInstructionsList), LocatorUtils.property(rightLocator"routeInstructionsList"rhsRouteInstructionsList), lhsRouteInstructionsListrhsRouteInstructionsList)));
            }
            {
                List<RouteMapTypelhsRouteMap;
                lhsRouteMap = leftObject.getRouteMap();
                List<RouteMapTyperhsRouteMap;
                rhsRouteMap = rightObject.getRouteMap();
                target.routeMap = null;
                List<RouteMapTypeuniqueRouteMapl = target.getRouteMap();
                uniqueRouteMapl.addAll(((List<RouteMapType> ) strategy.merge(LocatorUtils.property(leftLocator"routeMap"lhsRouteMap), LocatorUtils.property(rightLocator"routeMap"rhsRouteMap), lhsRouteMaprhsRouteMap)));
            }
        }
    }
    public void setRouteMap(List<RouteMapTypevalue) {
        List<RouteMapTypedraftl = this.getRouteMap();
        draftl.addAll(value);
    }
New to GrepCode? Check out our FAQ X