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, 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: 2015.04.16 at 07:22:02 AM CEST 
  //
  
  
  package net.opengis.arml.v_2_0;
 
 import java.util.List;

Java class for TrackableType complex type.

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

 <complexType name="TrackableType">
   <complexContent>
     <extension base="{http://www.opengis.net/arml/2.0}ARAnchorType">
       <sequence>
         <element name="config" maxOccurs="unbounded">
           <complexType>
             <complexContent>
               <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
                 <sequence>
                   <element name="tracker">
                     <complexType>
                       <complexContent>
                         <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
                           <attribute ref="{http://www.w3.org/1999/xlink}href use="required""/>
                         </restriction>
                       </complexContent>
                     </complexType>
                   </element>
                   <element name="src" type="{http://www.w3.org/2001/XMLSchema}string"/>
                 </sequence>
                 <attribute name="order" type="{http://www.w3.org/2001/XMLSchema}int" />
               </restriction>
             </complexContent>
           </complexType>
         </element>
         <element name="size" type="{http://www.w3.org/2001/XMLSchema}double" minOccurs="0"/>
       </sequence>
     </extension>
   </complexContent>
 </complexType>
 
 
 @XmlType(name = "TrackableType", propOrder = {
     "config",
     "size"
 })
 public class TrackableType
     extends ARAnchorType
     implements CloneableCopyToEqualsHashCodeMergeFromToString
 {
 
     @XmlElement(required = true)
     protected List<TrackableType.Configconfig;
     protected Double size;

    
Gets the value of the config 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 config property.

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

    getConfig().add(newItem);
 

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

    public List<TrackableType.ConfiggetConfig() {
        if ( == null) {
             = new ArrayList<TrackableType.Config>();
        }
        return this.;
    }

    
Gets the value of the size property.

Returns:
possible object is
    public Double getSize() {
        return ;
    }

    
Sets the value of the size property.

Parameters:
value allowed object is
    public void setSize(Double 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);
        {
            List<TrackableType.ConfigtheConfig;
            theConfig = (((this.!= null)&&(!this..isEmpty()))?this.getConfig():null);
            strategy.appendField(locatorthis"config"buffertheConfig);
        }
        {
            Double theSize;
            theSize = this.getSize();
            strategy.appendField(locatorthis"size"buffertheSize);
        }
        return buffer;
    }
    public boolean equals(ObjectLocator thisLocatorObjectLocator thatLocatorObject objectEqualsStrategy strategy) {
        if (!(object instanceof TrackableType)) {
            return false;
        }
        if (this == object) {
            return true;
        }
        if (!super.equals(thisLocatorthatLocatorobjectstrategy)) {
            return false;
        }
        final TrackableType that = ((TrackableTypeobject);
        {
            List<TrackableType.ConfiglhsConfig;
            lhsConfig = (((this.!= null)&&(!this..isEmpty()))?this.getConfig():null);
            List<TrackableType.ConfigrhsConfig;
            rhsConfig = (((that.config!= null)&&(!that.config.isEmpty()))?that.getConfig():null);
            if (!strategy.equals(LocatorUtils.property(thisLocator"config"lhsConfig), LocatorUtils.property(thatLocator"config"rhsConfig), lhsConfigrhsConfig)) {
                return false;
            }
        }
        {
            Double lhsSize;
            lhsSize = this.getSize();
            Double rhsSize;
            rhsSize = that.getSize();
            if (!strategy.equals(LocatorUtils.property(thisLocator"size"lhsSize), LocatorUtils.property(thatLocator"size"rhsSize), lhsSizerhsSize)) {
                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);
        {
            List<TrackableType.ConfigtheConfig;
            theConfig = (((this.!= null)&&(!this..isEmpty()))?this.getConfig():null);
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"config"theConfig), currentHashCodetheConfig);
        }
        {
            Double theSize;
            theSize = this.getSize();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"size"theSize), currentHashCodetheSize);
        }
        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 TrackableType) {
            final TrackableType copy = ((TrackableTypedraftCopy);
            if ((this.!= null)&&(!this..isEmpty())) {
                List<TrackableType.ConfigsourceConfig;
                sourceConfig = (((this.!= null)&&(!this..isEmpty()))?this.getConfig():null);
                @SuppressWarnings("unchecked")
                List<TrackableType.ConfigcopyConfig = ((List<TrackableType.Config> ) strategy.copy(LocatorUtils.property(locator"config"sourceConfig), sourceConfig));
                copy.config = null;
                if (copyConfig!= null) {
                    List<TrackableType.ConfiguniqueConfigl = copy.getConfig();
                    uniqueConfigl.addAll(copyConfig);
                }
            } else {
                copy.config = null;
            }
            if (this.!= null) {
                Double sourceSize;
                sourceSize = this.getSize();
                Double copySize = ((Doublestrategy.copy(LocatorUtils.property(locator"size"sourceSize), sourceSize));
                copy.setSize(copySize);
            } else {
                copy.size = null;
            }
        }
        return draftCopy;
    }
    public Object createNewInstance() {
        return new TrackableType();
    }
    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 TrackableType) {
            final TrackableType target = this;
            final TrackableType leftObject = ((TrackableTypeleft);
            final TrackableType rightObject = ((TrackableTyperight);
            {
                List<TrackableType.ConfiglhsConfig;
                lhsConfig = (((leftObject.config!= null)&&(!leftObject.config.isEmpty()))?leftObject.getConfig():null);
                List<TrackableType.ConfigrhsConfig;
                rhsConfig = (((rightObject.config!= null)&&(!rightObject.config.isEmpty()))?rightObject.getConfig():null);
                List<TrackableType.ConfigmergedConfig = ((List<TrackableType.Config> ) strategy.merge(LocatorUtils.property(leftLocator"config"lhsConfig), LocatorUtils.property(rightLocator"config"rhsConfig), lhsConfigrhsConfig));
                target.config = null;
                if (mergedConfig!= null) {
                    List<TrackableType.ConfiguniqueConfigl = target.getConfig();
                    uniqueConfigl.addAll(mergedConfig);
                }
            }
            {
                Double lhsSize;
                lhsSize = leftObject.getSize();
                Double rhsSize;
                rhsSize = rightObject.getSize();
                Double mergedSize = ((Doublestrategy.merge(LocatorUtils.property(leftLocator"size"lhsSize), LocatorUtils.property(rightLocator"size"rhsSize), lhsSizerhsSize));
                target.setSize(mergedSize);
            }
        }
    }
    public void setConfig(List<TrackableType.Configvalue) {
        this. = null;
        List<TrackableType.Configdraftl = this.getConfig();
        draftl.addAll(value);
    }
    public TrackableType withConfig(TrackableType.Config... values) {
        if (values!= null) {
            for (TrackableType.Config valuevalues) {
                getConfig().add(value);
            }
        }
        return this;
    }
        if (values!= null) {
            getConfig().addAll(values);
        }
        return this;
    }
    public TrackableType withSize(Double value) {
        setSize(value);
        return this;
    }
    public TrackableType withConfig(List<TrackableType.Configvalue) {
        setConfig(value);
        return this;
    }
    @Override
    public TrackableType withAssets(ARAnchorType.Assets value) {
        setAssets(value);
        return this;
    }
    @Override
    public TrackableType withEnabled(Boolean value) {
        setEnabled(value);
        return this;
    }
    @Override
    public TrackableType withId(String value) {
        setId(value);
        return this;
    }


    

Java class for anonymous complex type.

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

 <complexType>
   <complexContent>
     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
       <sequence>
         <element name="tracker">
           <complexType>
             <complexContent>
               <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
                 <attribute ref="{http://www.w3.org/1999/xlink}href use="required""/>
               </restriction>
             </complexContent>
           </complexType>
         </element>
         <element name="src" type="{http://www.w3.org/2001/XMLSchema}string"/>
       </sequence>
       <attribute name="order" type="{http://www.w3.org/2001/XMLSchema}int" />
     </restriction>
   </complexContent>
 </complexType>
 
    @XmlType(name = "", propOrder = {
        "tracker",
        "src"
    })
    public static class Config
        implements CloneableCopyToEqualsHashCodeMergeFromToString
    {
        @XmlElement(required = true)
        protected TrackableType.Config.Tracker tracker;
        @XmlElement(required = true)
        protected String src;
        @XmlAttribute(name = "order")
        protected Integer order;

        
Gets the value of the tracker property.

Returns:
possible object is
        public TrackableType.Config.Tracker getTracker() {
            return ;
        }

        
Sets the value of the tracker property.

Parameters:
value allowed object is
        public void setTracker(TrackableType.Config.Tracker value) {
            this. = value;
        }

        
Gets the value of the src property.

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

        
Sets the value of the src property.

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

        
Gets the value of the order property.

Returns:
possible object is
        public Integer getOrder() {
            return ;
        }

        
Sets the value of the order property.

Parameters:
value allowed object is
        public void setOrder(Integer 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) {
            {
                TrackableType.Config.Tracker theTracker;
                theTracker = this.getTracker();
                strategy.appendField(locatorthis"tracker"buffertheTracker);
            }
            {
                String theSrc;
                theSrc = this.getSrc();
                strategy.appendField(locatorthis"src"buffertheSrc);
            }
            {
                Integer theOrder;
                theOrder = this.getOrder();
                strategy.appendField(locatorthis"order"buffertheOrder);
            }
            return buffer;
        }
        public boolean equals(ObjectLocator thisLocatorObjectLocator thatLocatorObject objectEqualsStrategy strategy) {
            if (!(object instanceof TrackableType.Config)) {
                return false;
            }
            if (this == object) {
                return true;
            }
            final TrackableType.Config that = ((TrackableType.Configobject);
            {
                TrackableType.Config.Tracker lhsTracker;
                lhsTracker = this.getTracker();
                TrackableType.Config.Tracker rhsTracker;
                rhsTracker = that.getTracker();
                if (!strategy.equals(LocatorUtils.property(thisLocator"tracker"lhsTracker), LocatorUtils.property(thatLocator"tracker"rhsTracker), lhsTrackerrhsTracker)) {
                    return false;
                }
            }
            {
                String lhsSrc;
                lhsSrc = this.getSrc();
                String rhsSrc;
                rhsSrc = that.getSrc();
                if (!strategy.equals(LocatorUtils.property(thisLocator"src"lhsSrc), LocatorUtils.property(thatLocator"src"rhsSrc), lhsSrcrhsSrc)) {
                    return false;
                }
            }
            {
                Integer lhsOrder;
                lhsOrder = this.getOrder();
                Integer rhsOrder;
                rhsOrder = that.getOrder();
                if (!strategy.equals(LocatorUtils.property(thisLocator"order"lhsOrder), LocatorUtils.property(thatLocator"order"rhsOrder), lhsOrderrhsOrder)) {
                    return false;
                }
            }
            return true;
        }
        public boolean equals(Object object) {
            final EqualsStrategy strategy = .;
            return equals(nullnullobjectstrategy);
        }
        public int hashCode(ObjectLocator locatorHashCodeStrategy strategy) {
            int currentHashCode = 1;
            {
                TrackableType.Config.Tracker theTracker;
                theTracker = this.getTracker();
                currentHashCode = strategy.hashCode(LocatorUtils.property(locator"tracker"theTracker), currentHashCodetheTracker);
            }
            {
                String theSrc;
                theSrc = this.getSrc();
                currentHashCode = strategy.hashCode(LocatorUtils.property(locator"src"theSrc), currentHashCodetheSrc);
            }
            {
                Integer theOrder;
                theOrder = this.getOrder();
                currentHashCode = strategy.hashCode(LocatorUtils.property(locator"order"theOrder), currentHashCodetheOrder);
            }
            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);
            if (draftCopy instanceof TrackableType.Config) {
                final TrackableType.Config copy = ((TrackableType.ConfigdraftCopy);
                if (this.!= null) {
                    TrackableType.Config.Tracker sourceTracker;
                    sourceTracker = this.getTracker();
                    TrackableType.Config.Tracker copyTracker = ((TrackableType.Config.Trackerstrategy.copy(LocatorUtils.property(locator"tracker"sourceTracker), sourceTracker));
                    copy.setTracker(copyTracker);
                } else {
                    copy.tracker = null;
                }
                if (this.!= null) {
                    String sourceSrc;
                    sourceSrc = this.getSrc();
                    String copySrc = ((Stringstrategy.copy(LocatorUtils.property(locator"src"sourceSrc), sourceSrc));
                    copy.setSrc(copySrc);
                } else {
                    copy.src = null;
                }
                if (this.!= null) {
                    Integer sourceOrder;
                    sourceOrder = this.getOrder();
                    Integer copyOrder = ((Integerstrategy.copy(LocatorUtils.property(locator"order"sourceOrder), sourceOrder));
                    copy.setOrder(copyOrder);
                } else {
                    copy.order = null;
                }
            }
            return draftCopy;
        }
        public Object createNewInstance() {
            return new TrackableType.Config();
        }
        public void mergeFrom(Object leftObject right) {
            final MergeStrategy strategy = .;
            mergeFrom(nullnullleftrightstrategy);
        }
        public void mergeFrom(ObjectLocator leftLocatorObjectLocator rightLocatorObject leftObject rightMergeStrategy strategy) {
            if (right instanceof TrackableType.Config) {
                final TrackableType.Config target = this;
                final TrackableType.Config leftObject = ((TrackableType.Configleft);
                final TrackableType.Config rightObject = ((TrackableType.Configright);
                {
                    TrackableType.Config.Tracker lhsTracker;
                    lhsTracker = leftObject.getTracker();
                    TrackableType.Config.Tracker rhsTracker;
                    rhsTracker = rightObject.getTracker();
                    TrackableType.Config.Tracker mergedTracker = ((TrackableType.Config.Trackerstrategy.merge(LocatorUtils.property(leftLocator"tracker"lhsTracker), LocatorUtils.property(rightLocator"tracker"rhsTracker), lhsTrackerrhsTracker));
                    target.setTracker(mergedTracker);
                }
                {
                    String lhsSrc;
                    lhsSrc = leftObject.getSrc();
                    String rhsSrc;
                    rhsSrc = rightObject.getSrc();
                    String mergedSrc = ((Stringstrategy.merge(LocatorUtils.property(leftLocator"src"lhsSrc), LocatorUtils.property(rightLocator"src"rhsSrc), lhsSrcrhsSrc));
                    target.setSrc(mergedSrc);
                }
                {
                    Integer lhsOrder;
                    lhsOrder = leftObject.getOrder();
                    Integer rhsOrder;
                    rhsOrder = rightObject.getOrder();
                    Integer mergedOrder = ((Integerstrategy.merge(LocatorUtils.property(leftLocator"order"lhsOrder), LocatorUtils.property(rightLocator"order"rhsOrder), lhsOrderrhsOrder));
                    target.setOrder(mergedOrder);
                }
            }
        }
        public TrackableType.Config withTracker(TrackableType.Config.Tracker value) {
            setTracker(value);
            return this;
        }
        public TrackableType.Config withSrc(String value) {
            setSrc(value);
            return this;
        }
        public TrackableType.Config withOrder(Integer value) {
            setOrder(value);
            return this;
        }


        

Java class for anonymous complex type.

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

 <complexType>
   <complexContent>
     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
       <attribute ref="{http://www.w3.org/1999/xlink}href use="required""/>
     </restriction>
   </complexContent>
 </complexType>
 
        @XmlType(name = "")
        public static class Tracker
            implements CloneableCopyToEqualsHashCodeMergeFromToString
        {
            @XmlAttribute(name = "href", namespace = "http://www.w3.org/1999/xlink", required = true)
            protected String href;

            
Gets the value of the href property.

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

            
Sets the value of the href property.

Parameters:
value allowed object is
            public void setHref(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) {
                {
                    String theHref;
                    theHref = this.getHref();
                    strategy.appendField(locatorthis"href"buffertheHref);
                }
                return buffer;
            }
            public boolean equals(ObjectLocator thisLocatorObjectLocator thatLocatorObject objectEqualsStrategy strategy) {
                if (!(object instanceof TrackableType.Config.Tracker)) {
                    return false;
                }
                if (this == object) {
                    return true;
                }
                final TrackableType.Config.Tracker that = ((TrackableType.Config.Trackerobject);
                {
                    String lhsHref;
                    lhsHref = this.getHref();
                    String rhsHref;
                    rhsHref = that.getHref();
                    if (!strategy.equals(LocatorUtils.property(thisLocator"href"lhsHref), LocatorUtils.property(thatLocator"href"rhsHref), lhsHrefrhsHref)) {
                        return false;
                    }
                }
                return true;
            }
            public boolean equals(Object object) {
                final EqualsStrategy strategy = .;
                return equals(nullnullobjectstrategy);
            }
            public int hashCode(ObjectLocator locatorHashCodeStrategy strategy) {
                int currentHashCode = 1;
                {
                    String theHref;
                    theHref = this.getHref();
                    currentHashCode = strategy.hashCode(LocatorUtils.property(locator"href"theHref), currentHashCodetheHref);
                }
                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);
                if (draftCopy instanceof TrackableType.Config.Tracker) {
                    final TrackableType.Config.Tracker copy = ((TrackableType.Config.TrackerdraftCopy);
                    if (this.!= null) {
                        String sourceHref;
                        sourceHref = this.getHref();
                        String copyHref = ((Stringstrategy.copy(LocatorUtils.property(locator"href"sourceHref), sourceHref));
                        copy.setHref(copyHref);
                    } else {
                        copy.href = null;
                    }
                }
                return draftCopy;
            }
            public Object createNewInstance() {
                return new TrackableType.Config.Tracker();
            }
            public void mergeFrom(Object leftObject right) {
                final MergeStrategy strategy = .;
                mergeFrom(nullnullleftrightstrategy);
            }
            public void mergeFrom(ObjectLocator leftLocatorObjectLocator rightLocatorObject leftObject rightMergeStrategy strategy) {
                if (right instanceof TrackableType.Config.Tracker) {
                    final TrackableType.Config.Tracker target = this;
                    final TrackableType.Config.Tracker leftObject = ((TrackableType.Config.Trackerleft);
                    final TrackableType.Config.Tracker rightObject = ((TrackableType.Config.Trackerright);
                    {
                        String lhsHref;
                        lhsHref = leftObject.getHref();
                        String rhsHref;
                        rhsHref = rightObject.getHref();
                        String mergedHref = ((Stringstrategy.merge(LocatorUtils.property(leftLocator"href"lhsHref), LocatorUtils.property(rightLocator"href"rhsHref), lhsHrefrhsHref));
                        target.setHref(mergedHref);
                    }
                }
            }
            public TrackableType.Config.Tracker withHref(String value) {
                setHref(value);
                return this;
            }
        }
    }
New to GrepCode? Check out our FAQ X