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.03.28 at 10:20:34 AM CET 
  //
  
  
  package net.opengis.iso19139.gmd.v_20060504;
 
 import java.util.List;
Quantitative_conformance_measure from Quality Procedures. - - Renamed to remove implied use limitation - - OCL - -- result is type specified by valueDomain - result.tupleType = valueDomain

Java class for DQ_QuantitativeResult_Type complex type.

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

 <complexType name="DQ_QuantitativeResult_Type">
   <complexContent>
     <extension base="{http://www.isotc211.org/2005/gmd}AbstractDQ_Result_Type">
       <sequence>
         <element name="valueType" type="{http://www.isotc211.org/2005/gco}RecordType_PropertyType" minOccurs="0"/>
         <element name="valueUnit" type="{http://www.isotc211.org/2005/gco}UnitOfMeasure_PropertyType"/>
         <element name="errorStatistic" type="{http://www.isotc211.org/2005/gco}CharacterString_PropertyType" minOccurs="0"/>
         <element name="value" type="{http://www.isotc211.org/2005/gco}Record_PropertyType" maxOccurs="unbounded"/>
       </sequence>
     </extension>
   </complexContent>
 </complexType>
 
 
 @XmlType(name = "DQ_QuantitativeResult_Type", propOrder = {
     "valueType",
     "valueUnit",
     "errorStatistic",
     "value"
 })
     extends AbstractDQResultType
     implements CloneableCopyToEqualsHashCodeMergeFromToString
 {
 
     protected RecordTypePropertyType valueType;
     @XmlElement(required = true)
     protected UnitOfMeasurePropertyType valueUnit;
     @XmlElement(required = true)
     protected List<RecordPropertyTypevalue;

    
Gets the value of the valueType property.

Returns:
possible object is
 
     public RecordTypePropertyType getValueType() {
         return ;
     }

    
Sets the value of the valueType property.

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

    
Gets the value of the valueUnit property.

Returns:
possible object is
        return ;
    }

    
Sets the value of the valueUnit property.

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

    
Gets the value of the errorStatistic property.

Returns:
possible object is
        return ;
    }

    
Sets the value of the errorStatistic property.

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

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

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

    getValue().add(newItem);
 

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

    public List<RecordPropertyTypegetValue() {
        if ( == null) {
             = new ArrayList<RecordPropertyType>();
        }
        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);
        {
            RecordTypePropertyType theValueType;
            theValueType = this.getValueType();
            strategy.appendField(locatorthis"valueType"buffertheValueType);
        }
        {
            UnitOfMeasurePropertyType theValueUnit;
            theValueUnit = this.getValueUnit();
            strategy.appendField(locatorthis"valueUnit"buffertheValueUnit);
        }
        {
            CharacterStringPropertyType theErrorStatistic;
            theErrorStatistic = this.getErrorStatistic();
            strategy.appendField(locatorthis"errorStatistic"buffertheErrorStatistic);
        }
        {
            List<RecordPropertyTypetheValue;
            theValue = (((this.!= null)&&(!this..isEmpty()))?this.getValue():null);
            strategy.appendField(locatorthis"value"buffertheValue);
        }
        return buffer;
    }
    public boolean equals(ObjectLocator thisLocatorObjectLocator thatLocatorObject objectEqualsStrategy strategy) {
        if (!(object instanceof DQQuantitativeResultType)) {
            return false;
        }
        if (this == object) {
            return true;
        }
        if (!super.equals(thisLocatorthatLocatorobjectstrategy)) {
            return false;
        }
        final DQQuantitativeResultType that = ((DQQuantitativeResultTypeobject);
        {
            RecordTypePropertyType lhsValueType;
            lhsValueType = this.getValueType();
            RecordTypePropertyType rhsValueType;
            rhsValueType = that.getValueType();
            if (!strategy.equals(LocatorUtils.property(thisLocator"valueType"lhsValueType), LocatorUtils.property(thatLocator"valueType"rhsValueType), lhsValueTyperhsValueType)) {
                return false;
            }
        }
        {
            UnitOfMeasurePropertyType lhsValueUnit;
            lhsValueUnit = this.getValueUnit();
            UnitOfMeasurePropertyType rhsValueUnit;
            rhsValueUnit = that.getValueUnit();
            if (!strategy.equals(LocatorUtils.property(thisLocator"valueUnit"lhsValueUnit), LocatorUtils.property(thatLocator"valueUnit"rhsValueUnit), lhsValueUnitrhsValueUnit)) {
                return false;
            }
        }
        {
            CharacterStringPropertyType lhsErrorStatistic;
            lhsErrorStatistic = this.getErrorStatistic();
            CharacterStringPropertyType rhsErrorStatistic;
            rhsErrorStatistic = that.getErrorStatistic();
            if (!strategy.equals(LocatorUtils.property(thisLocator"errorStatistic"lhsErrorStatistic), LocatorUtils.property(thatLocator"errorStatistic"rhsErrorStatistic), lhsErrorStatisticrhsErrorStatistic)) {
                return false;
            }
        }
        {
            List<RecordPropertyTypelhsValue;
            lhsValue = (((this.!= null)&&(!this..isEmpty()))?this.getValue():null);
            List<RecordPropertyTyperhsValue;
            rhsValue = (((that.value!= null)&&(!that.value.isEmpty()))?that.getValue():null);
            if (!strategy.equals(LocatorUtils.property(thisLocator"value"lhsValue), LocatorUtils.property(thatLocator"value"rhsValue), lhsValuerhsValue)) {
                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);
        {
            RecordTypePropertyType theValueType;
            theValueType = this.getValueType();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"valueType"theValueType), currentHashCodetheValueType);
        }
        {
            UnitOfMeasurePropertyType theValueUnit;
            theValueUnit = this.getValueUnit();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"valueUnit"theValueUnit), currentHashCodetheValueUnit);
        }
        {
            CharacterStringPropertyType theErrorStatistic;
            theErrorStatistic = this.getErrorStatistic();
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"errorStatistic"theErrorStatistic), currentHashCodetheErrorStatistic);
        }
        {
            List<RecordPropertyTypetheValue;
            theValue = (((this.!= null)&&(!this..isEmpty()))?this.getValue():null);
            currentHashCode = strategy.hashCode(LocatorUtils.property(locator"value"theValue), currentHashCodetheValue);
        }
        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 DQQuantitativeResultType) {
            final DQQuantitativeResultType copy = ((DQQuantitativeResultTypedraftCopy);
            if (this.!= null) {
                RecordTypePropertyType sourceValueType;
                sourceValueType = this.getValueType();
                RecordTypePropertyType copyValueType = ((RecordTypePropertyTypestrategy.copy(LocatorUtils.property(locator"valueType"sourceValueType), sourceValueType));
                copy.setValueType(copyValueType);
            } else {
                copy.valueType = null;
            }
            if (this.!= null) {
                UnitOfMeasurePropertyType sourceValueUnit;
                sourceValueUnit = this.getValueUnit();
                UnitOfMeasurePropertyType copyValueUnit = ((UnitOfMeasurePropertyTypestrategy.copy(LocatorUtils.property(locator"valueUnit"sourceValueUnit), sourceValueUnit));
                copy.setValueUnit(copyValueUnit);
            } else {
                copy.valueUnit = null;
            }
            if (this.!= null) {
                CharacterStringPropertyType sourceErrorStatistic;
                sourceErrorStatistic = this.getErrorStatistic();
                CharacterStringPropertyType copyErrorStatistic = ((CharacterStringPropertyTypestrategy.copy(LocatorUtils.property(locator"errorStatistic"sourceErrorStatistic), sourceErrorStatistic));
                copy.setErrorStatistic(copyErrorStatistic);
            } else {
                copy.errorStatistic = null;
            }
            if ((this.!= null)&&(!this..isEmpty())) {
                List<RecordPropertyTypesourceValue;
                sourceValue = (((this.!= null)&&(!this..isEmpty()))?this.getValue():null);
                @SuppressWarnings("unchecked")
                List<RecordPropertyTypecopyValue = ((List<RecordPropertyType> ) strategy.copy(LocatorUtils.property(locator"value"sourceValue), sourceValue));
                copy.value = null;
                if (copyValue!= null) {
                    List<RecordPropertyTypeuniqueValuel = copy.getValue();
                    uniqueValuel.addAll(copyValue);
                }
            } else {
                copy.value = null;
            }
        }
        return draftCopy;
    }
    public Object createNewInstance() {
        return new DQQuantitativeResultType();
    }
    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 DQQuantitativeResultType) {
            final DQQuantitativeResultType target = this;
            final DQQuantitativeResultType leftObject = ((DQQuantitativeResultTypeleft);
            final DQQuantitativeResultType rightObject = ((DQQuantitativeResultTyperight);
            {
                RecordTypePropertyType lhsValueType;
                lhsValueType = leftObject.getValueType();
                RecordTypePropertyType rhsValueType;
                rhsValueType = rightObject.getValueType();
                RecordTypePropertyType mergedValueType = ((RecordTypePropertyTypestrategy.merge(LocatorUtils.property(leftLocator"valueType"lhsValueType), LocatorUtils.property(rightLocator"valueType"rhsValueType), lhsValueTyperhsValueType));
                target.setValueType(mergedValueType);
            }
            {
                UnitOfMeasurePropertyType lhsValueUnit;
                lhsValueUnit = leftObject.getValueUnit();
                UnitOfMeasurePropertyType rhsValueUnit;
                rhsValueUnit = rightObject.getValueUnit();
                UnitOfMeasurePropertyType mergedValueUnit = ((UnitOfMeasurePropertyTypestrategy.merge(LocatorUtils.property(leftLocator"valueUnit"lhsValueUnit), LocatorUtils.property(rightLocator"valueUnit"rhsValueUnit), lhsValueUnitrhsValueUnit));
                target.setValueUnit(mergedValueUnit);
            }
            {
                CharacterStringPropertyType lhsErrorStatistic;
                lhsErrorStatistic = leftObject.getErrorStatistic();
                CharacterStringPropertyType rhsErrorStatistic;
                rhsErrorStatistic = rightObject.getErrorStatistic();
                CharacterStringPropertyType mergedErrorStatistic = ((CharacterStringPropertyTypestrategy.merge(LocatorUtils.property(leftLocator"errorStatistic"lhsErrorStatistic), LocatorUtils.property(rightLocator"errorStatistic"rhsErrorStatistic), lhsErrorStatisticrhsErrorStatistic));
                target.setErrorStatistic(mergedErrorStatistic);
            }
            {
                List<RecordPropertyTypelhsValue;
                lhsValue = (((leftObject.value!= null)&&(!leftObject.value.isEmpty()))?leftObject.getValue():null);
                List<RecordPropertyTyperhsValue;
                rhsValue = (((rightObject.value!= null)&&(!rightObject.value.isEmpty()))?rightObject.getValue():null);
                List<RecordPropertyTypemergedValue = ((List<RecordPropertyType> ) strategy.merge(LocatorUtils.property(leftLocator"value"lhsValue), LocatorUtils.property(rightLocator"value"rhsValue), lhsValuerhsValue));
                target.value = null;
                if (mergedValue!= null) {
                    List<RecordPropertyTypeuniqueValuel = target.getValue();
                    uniqueValuel.addAll(mergedValue);
                }
            }
        }
    }
    public void setValue(List<RecordPropertyTypevalue) {
        this. = null;
        List<RecordPropertyTypedraftl = this.getValue();
        draftl.addAll(value);
    }
        setValueType(value);
        return this;
    }
        setValueUnit(value);
        return this;
    }
        setErrorStatistic(value);
        return this;
    }
        if (values!= null) {
            for (RecordPropertyType valuevalues) {
                getValue().add(value);
            }
        }
        return this;
    }
        if (values!= null) {
            getValue().addAll(values);
        }
        return this;
    }
        setValue(value);
        return this;
    }
    @Override
    public DQQuantitativeResultType withId(String value) {
        setId(value);
        return this;
    }
    @Override
    public DQQuantitativeResultType withUuid(String value) {
        setUuid(value);
        return this;
    }
New to GrepCode? Check out our FAQ X