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;
 
The data elements that make up the name of a street. There are two valid methods for encoding this information: 1). Use the structured elements and attributes. 2). The element value may contain a simplified string (e.g. 43 West 83rd. Street). An example:
 <?xml version="1.0" encoding="UTF-8"?><Street xmlns="http://www.w3.org/2001/XMLSchema" xmlns:gml="http://www.opengis.net/gml" xmlns:xls="http://www.opengis.net/xls" directionalPrefix="W" officialName="83RD" typeSuffix="ST"/>
 

Java-Klasse für StreetNameType complex type.

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

 <complexType name="StreetNameType">
   <simpleContent>
     <extension base="<http://www.w3.org/2001/XMLSchema>string">
       <attribute name="directionalPrefix" type="{http://www.w3.org/2001/XMLSchema}string" />
       <attribute name="typePrefix" type="{http://www.w3.org/2001/XMLSchema}string" />
       <attribute name="officialName" type="{http://www.w3.org/2001/XMLSchema}string" />
       <attribute name="typeSuffix" type="{http://www.w3.org/2001/XMLSchema}string" />
       <attribute name="directionalSuffix" type="{http://www.w3.org/2001/XMLSchema}string" />
       <attribute name="muniOctant" type="{http://www.opengis.net/gml}CompassPointEnumeration" />
     </extension>
   </simpleContent>
 </complexType>
 
 
 @XmlType(name = "StreetNameType", propOrder = {
     "value"
 })
 public class StreetNameType
     implements CloneableCopyToEqualsHashCodeMergeFromToString
 {
 
     @XmlValue
     protected String value;
     @XmlAttribute(name = "directionalPrefix")
     protected String directionalPrefix;
     @XmlAttribute(name = "typePrefix")
     protected String typePrefix;
     @XmlAttribute(name = "officialName")
     protected String officialName;
     @XmlAttribute(name = "typeSuffix")
     protected String typeSuffix;
     @XmlAttribute(name = "directionalSuffix")
     protected String directionalSuffix;
     @XmlAttribute(name = "muniOctant")
     protected CompassPointEnumeration muniOctant;

    
Ruft den Wert der value-Eigenschaft ab.

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

    
Legt den Wert der value-Eigenschaft fest.

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

    
Ruft den Wert der directionalPrefix-Eigenschaft ab.

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

    
Legt den Wert der directionalPrefix-Eigenschaft fest.

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

    
Ruft den Wert der typePrefix-Eigenschaft ab.

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

    
Legt den Wert der typePrefix-Eigenschaft fest.

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

    
Ruft den Wert der officialName-Eigenschaft ab.

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

    
Legt den Wert der officialName-Eigenschaft fest.

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

    
Ruft den Wert der typeSuffix-Eigenschaft ab.

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

    
Legt den Wert der typeSuffix-Eigenschaft fest.

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

    
Ruft den Wert der directionalSuffix-Eigenschaft ab.

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

    
Legt den Wert der directionalSuffix-Eigenschaft fest.

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

    
Ruft den Wert der muniOctant-Eigenschaft ab.

Returns:
possible object is
        return ;
    }

    
Legt den Wert der muniOctant-Eigenschaft fest.

Parameters:
value allowed object is
    public void setMuniOctant(CompassPointEnumeration 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 theValue;
            theValue = this.getValue();
            strategy.appendField(locatorthis"value"buffertheValue);
        }
        {
            String theDirectionalPrefix;
            theDirectionalPrefix = this.getDirectionalPrefix();
            strategy.appendField(locatorthis"directionalPrefix"buffertheDirectionalPrefix);
        }
        {
            String theTypePrefix;
            theTypePrefix = this.getTypePrefix();
            strategy.appendField(locatorthis"typePrefix"buffertheTypePrefix);
        }
        {
            String theOfficialName;
            theOfficialName = this.getOfficialName();
            strategy.appendField(locatorthis"officialName"buffertheOfficialName);
        }
        {
            String theTypeSuffix;
            theTypeSuffix = this.getTypeSuffix();
            strategy.appendField(locatorthis"typeSuffix"buffertheTypeSuffix);
        }
        {
            String theDirectionalSuffix;
            theDirectionalSuffix = this.getDirectionalSuffix();
            strategy.appendField(locatorthis"directionalSuffix"buffertheDirectionalSuffix);
        }
        {
            CompassPointEnumeration theMuniOctant;
            theMuniOctant = this.getMuniOctant();
            strategy.appendField(locatorthis"muniOctant"buffertheMuniOctant);
        }
        return buffer;
    }
    public boolean equals(ObjectLocator thisLocatorObjectLocator thatLocatorObject objectEqualsStrategy strategy) {
        if (!(object instanceof StreetNameType)) {
            return false;
        }
        if (this == object) {
            return true;
        }
        final StreetNameType that = ((StreetNameTypeobject);
        {
            String lhsValue;
            lhsValue = this.getValue();
            String rhsValue;
            rhsValue = that.getValue();
            if (!strategy.equals(LocatorUtils.property(thisLocator"value"lhsValue), LocatorUtils.property(thatLocator"value"rhsValue), lhsValuerhsValue)) {
                return false;
            }
        }
        {
            String lhsDirectionalPrefix;
            lhsDirectionalPrefix = this.getDirectionalPrefix();
            String rhsDirectionalPrefix;
            rhsDirectionalPrefix = that.getDirectionalPrefix();
            if (!strategy.equals(LocatorUtils.property(thisLocator"directionalPrefix"lhsDirectionalPrefix), LocatorUtils.property(thatLocator"directionalPrefix"rhsDirectionalPrefix), lhsDirectionalPrefixrhsDirectionalPrefix)) {
                return false;
            }
        }
        {
            String lhsTypePrefix;
            lhsTypePrefix = this.getTypePrefix();
            String rhsTypePrefix;
            rhsTypePrefix = that.getTypePrefix();
            if (!strategy.equals(LocatorUtils.property(thisLocator"typePrefix"lhsTypePrefix), LocatorUtils.property(thatLocator"typePrefix"rhsTypePrefix), lhsTypePrefixrhsTypePrefix)) {
                return false;
            }
        }
        {
            String lhsOfficialName;
            lhsOfficialName = this.getOfficialName();
            String rhsOfficialName;
            rhsOfficialName = that.getOfficialName();
            if (!strategy.equals(LocatorUtils.property(thisLocator"officialName"lhsOfficialName), LocatorUtils.property(thatLocator"officialName"rhsOfficialName), lhsOfficialNamerhsOfficialName)) {
                return false;
            }
        }
        {
            String lhsTypeSuffix;
            lhsTypeSuffix = this.getTypeSuffix();
            String rhsTypeSuffix;
            rhsTypeSuffix = that.getTypeSuffix();
            if (!strategy.equals(LocatorUtils.property(thisLocator"typeSuffix"lhsTypeSuffix), LocatorUtils.property(thatLocator"typeSuffix"rhsTypeSuffix), lhsTypeSuffixrhsTypeSuffix)) {
                return false;
            }
        }
        {
            String lhsDirectionalSuffix;
            lhsDirectionalSuffix = this.getDirectionalSuffix();
            String rhsDirectionalSuffix;
            rhsDirectionalSuffix = that.getDirectionalSuffix();
            if (!strategy.equals(LocatorUtils.property(thisLocator"directionalSuffix"lhsDirectionalSuffix), LocatorUtils.property(thatLocator"directionalSuffix"rhsDirectionalSuffix), lhsDirectionalSuffixrhsDirectionalSuffix)) {
                return false;
            }
        }
        {
            CompassPointEnumeration lhsMuniOctant;
            lhsMuniOctant = this.getMuniOctant();
            CompassPointEnumeration rhsMuniOctant;
            rhsMuniOctant = that.getMuniOctant();
            if (!strategy.equals(LocatorUtils.property(thisLocator"muniOctant"lhsMuniOctant), LocatorUtils.property(thatLocator"muniOctant"rhsMuniOctant), lhsMuniOctantrhsMuniOctant)) {
                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 theValue;
            theValue = this.getValue();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"value"theValue), currentHashCodetheValue);
        }
        {
            String theDirectionalPrefix;
            theDirectionalPrefix = this.getDirectionalPrefix();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"directionalPrefix"theDirectionalPrefix), currentHashCodetheDirectionalPrefix);
        }
        {
            String theTypePrefix;
            theTypePrefix = this.getTypePrefix();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"typePrefix"theTypePrefix), currentHashCodetheTypePrefix);
        }
        {
            String theOfficialName;
            theOfficialName = this.getOfficialName();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"officialName"theOfficialName), currentHashCodetheOfficialName);
        }
        {
            String theTypeSuffix;
            theTypeSuffix = this.getTypeSuffix();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"typeSuffix"theTypeSuffix), currentHashCodetheTypeSuffix);
        }
        {
            String theDirectionalSuffix;
            theDirectionalSuffix = this.getDirectionalSuffix();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"directionalSuffix"theDirectionalSuffix), currentHashCodetheDirectionalSuffix);
        }
        {
            CompassPointEnumeration theMuniOctant;
            theMuniOctant = this.getMuniOctant();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"muniOctant"theMuniOctant), currentHashCodetheMuniOctant);
        }
        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 StreetNameType) {
            final StreetNameType copy = ((StreetNameTypedraftCopy);
            if (this.!= null) {
                String sourceValue;
                sourceValue = this.getValue();
                String copyValue = ((Stringstrategy.copy(LocatorUtils.property(locator"value"sourceValue), sourceValue));
                copy.setValue(copyValue);
            } else {
                copy.value = null;
            }
            if (this.!= null) {
                String sourceDirectionalPrefix;
                sourceDirectionalPrefix = this.getDirectionalPrefix();
                String copyDirectionalPrefix = ((Stringstrategy.copy(LocatorUtils.property(locator"directionalPrefix"sourceDirectionalPrefix), sourceDirectionalPrefix));
                copy.setDirectionalPrefix(copyDirectionalPrefix);
            } else {
                copy.directionalPrefix = null;
            }
            if (this.!= null) {
                String sourceTypePrefix;
                sourceTypePrefix = this.getTypePrefix();
                String copyTypePrefix = ((Stringstrategy.copy(LocatorUtils.property(locator"typePrefix"sourceTypePrefix), sourceTypePrefix));
                copy.setTypePrefix(copyTypePrefix);
            } else {
                copy.typePrefix = null;
            }
            if (this.!= null) {
                String sourceOfficialName;
                sourceOfficialName = this.getOfficialName();
                String copyOfficialName = ((Stringstrategy.copy(LocatorUtils.property(locator"officialName"sourceOfficialName), sourceOfficialName));
                copy.setOfficialName(copyOfficialName);
            } else {
                copy.officialName = null;
            }
            if (this.!= null) {
                String sourceTypeSuffix;
                sourceTypeSuffix = this.getTypeSuffix();
                String copyTypeSuffix = ((Stringstrategy.copy(LocatorUtils.property(locator"typeSuffix"sourceTypeSuffix), sourceTypeSuffix));
                copy.setTypeSuffix(copyTypeSuffix);
            } else {
                copy.typeSuffix = null;
            }
            if (this.!= null) {
                String sourceDirectionalSuffix;
                sourceDirectionalSuffix = this.getDirectionalSuffix();
                String copyDirectionalSuffix = ((Stringstrategy.copy(LocatorUtils.property(locator"directionalSuffix"sourceDirectionalSuffix), sourceDirectionalSuffix));
                copy.setDirectionalSuffix(copyDirectionalSuffix);
            } else {
                copy.directionalSuffix = null;
            }
            if (this.!= null) {
                CompassPointEnumeration sourceMuniOctant;
                sourceMuniOctant = this.getMuniOctant();
                CompassPointEnumeration copyMuniOctant = ((CompassPointEnumerationstrategy.copy(LocatorUtils.property(locator"muniOctant"sourceMuniOctant), sourceMuniOctant));
                copy.setMuniOctant(copyMuniOctant);
            } else {
                copy.muniOctant = null;
            }
        }
        return draftCopy;
    }
    public Object createNewInstance() {
        return new StreetNameType();
    }
    public void mergeFrom(Object leftObject right) {
        final MergeStrategy strategy = .;
        mergeFrom(nullnullleftrightstrategy);
    }
    public void mergeFrom(ObjectLocator leftLocatorObjectLocator rightLocatorObject leftObject rightMergeStrategy strategy) {
        if (right instanceof StreetNameType) {
            final StreetNameType target = this;
            final StreetNameType leftObject = ((StreetNameTypeleft);
            final StreetNameType rightObject = ((StreetNameTyperight);
            {
                String lhsValue;
                lhsValue = leftObject.getValue();
                String rhsValue;
                rhsValue = rightObject.getValue();
                target.setValue(((Stringstrategy.merge(LocatorUtils.property(leftLocator"value"lhsValue), LocatorUtils.property(rightLocator"value"rhsValue), lhsValuerhsValue)));
            }
            {
                String lhsDirectionalPrefix;
                lhsDirectionalPrefix = leftObject.getDirectionalPrefix();
                String rhsDirectionalPrefix;
                rhsDirectionalPrefix = rightObject.getDirectionalPrefix();
                target.setDirectionalPrefix(((Stringstrategy.merge(LocatorUtils.property(leftLocator"directionalPrefix"lhsDirectionalPrefix), LocatorUtils.property(rightLocator"directionalPrefix"rhsDirectionalPrefix), lhsDirectionalPrefixrhsDirectionalPrefix)));
            }
            {
                String lhsTypePrefix;
                lhsTypePrefix = leftObject.getTypePrefix();
                String rhsTypePrefix;
                rhsTypePrefix = rightObject.getTypePrefix();
                target.setTypePrefix(((Stringstrategy.merge(LocatorUtils.property(leftLocator"typePrefix"lhsTypePrefix), LocatorUtils.property(rightLocator"typePrefix"rhsTypePrefix), lhsTypePrefixrhsTypePrefix)));
            }
            {
                String lhsOfficialName;
                lhsOfficialName = leftObject.getOfficialName();
                String rhsOfficialName;
                rhsOfficialName = rightObject.getOfficialName();
                target.setOfficialName(((Stringstrategy.merge(LocatorUtils.property(leftLocator"officialName"lhsOfficialName), LocatorUtils.property(rightLocator"officialName"rhsOfficialName), lhsOfficialNamerhsOfficialName)));
            }
            {
                String lhsTypeSuffix;
                lhsTypeSuffix = leftObject.getTypeSuffix();
                String rhsTypeSuffix;
                rhsTypeSuffix = rightObject.getTypeSuffix();
                target.setTypeSuffix(((Stringstrategy.merge(LocatorUtils.property(leftLocator"typeSuffix"lhsTypeSuffix), LocatorUtils.property(rightLocator"typeSuffix"rhsTypeSuffix), lhsTypeSuffixrhsTypeSuffix)));
            }
            {
                String lhsDirectionalSuffix;
                lhsDirectionalSuffix = leftObject.getDirectionalSuffix();
                String rhsDirectionalSuffix;
                rhsDirectionalSuffix = rightObject.getDirectionalSuffix();
                target.setDirectionalSuffix(((Stringstrategy.merge(LocatorUtils.property(leftLocator"directionalSuffix"lhsDirectionalSuffix), LocatorUtils.property(rightLocator"directionalSuffix"rhsDirectionalSuffix), lhsDirectionalSuffixrhsDirectionalSuffix)));
            }
            {
                CompassPointEnumeration lhsMuniOctant;
                lhsMuniOctant = leftObject.getMuniOctant();
                CompassPointEnumeration rhsMuniOctant;
                rhsMuniOctant = rightObject.getMuniOctant();
                target.setMuniOctant(((CompassPointEnumerationstrategy.merge(LocatorUtils.property(leftLocator"muniOctant"lhsMuniOctant), LocatorUtils.property(rightLocator"muniOctant"rhsMuniOctant), lhsMuniOctantrhsMuniOctant)));
            }
        }
    }
New to GrepCode? Check out our FAQ X