All Downloads are FREE. Search and download functionalities are using the official Maven repository.

net.opengis.swe.x10.impl.AbstractConditionalTypeImpl Maven / Gradle / Ivy

/*
 * XML Type:  AbstractConditionalType
 * Namespace: http://www.opengis.net/swe/1.0
 * Java type: net.opengis.swe.x10.AbstractConditionalType
 *
 * Automatically generated - do not modify.
 */
package net.opengis.swe.x10.impl;
/**
 * An XML AbstractConditionalType(@http://www.opengis.net/swe/1.0).
 *
 * This is a complex type.
 */
public class AbstractConditionalTypeImpl extends net.opengis.swe.x10.impl.AbstractDataRecordTypeImpl implements net.opengis.swe.x10.AbstractConditionalType
{
    private static final long serialVersionUID = 1L;
    
    public AbstractConditionalTypeImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName CONDITION$0 = 
        new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "condition");
    
    
    /**
     * Gets array of all "condition" elements
     */
    public net.opengis.swe.x10.AbstractConditionalType.Condition[] getConditionArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CONDITION$0, targetList);
            net.opengis.swe.x10.AbstractConditionalType.Condition[] result = new net.opengis.swe.x10.AbstractConditionalType.Condition[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "condition" element
     */
    public net.opengis.swe.x10.AbstractConditionalType.Condition getConditionArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.swe.x10.AbstractConditionalType.Condition target = null;
            target = (net.opengis.swe.x10.AbstractConditionalType.Condition)get_store().find_element_user(CONDITION$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "condition" element
     */
    public int sizeOfConditionArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CONDITION$0);
        }
    }
    
    /**
     * Sets array of all "condition" element
     */
    public void setConditionArray(net.opengis.swe.x10.AbstractConditionalType.Condition[] conditionArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(conditionArray, CONDITION$0);
        }
    }
    
    /**
     * Sets ith "condition" element
     */
    public void setConditionArray(int i, net.opengis.swe.x10.AbstractConditionalType.Condition condition)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.swe.x10.AbstractConditionalType.Condition target = null;
            target = (net.opengis.swe.x10.AbstractConditionalType.Condition)get_store().find_element_user(CONDITION$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(condition);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "condition" element
     */
    public net.opengis.swe.x10.AbstractConditionalType.Condition insertNewCondition(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.swe.x10.AbstractConditionalType.Condition target = null;
            target = (net.opengis.swe.x10.AbstractConditionalType.Condition)get_store().insert_element_user(CONDITION$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "condition" element
     */
    public net.opengis.swe.x10.AbstractConditionalType.Condition addNewCondition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.swe.x10.AbstractConditionalType.Condition target = null;
            target = (net.opengis.swe.x10.AbstractConditionalType.Condition)get_store().add_element_user(CONDITION$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "condition" element
     */
    public void removeCondition(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CONDITION$0, i);
        }
    }
    /**
     * An XML condition(@http://www.opengis.net/swe/1.0).
     *
     * This is a complex type.
     */
    public static class ConditionImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.swe.x10.AbstractConditionalType.Condition
    {
        private static final long serialVersionUID = 1L;
        
        public ConditionImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName COUNT$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Count");
        private static final javax.xml.namespace.QName QUANTITY$2 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Quantity");
        private static final javax.xml.namespace.QName TIME$4 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Time");
        private static final javax.xml.namespace.QName BOOLEAN$6 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Boolean");
        private static final javax.xml.namespace.QName CATEGORY$8 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Category");
        private static final javax.xml.namespace.QName TEXT$10 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Text");
        private static final javax.xml.namespace.QName QUANTITYRANGE$12 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "QuantityRange");
        private static final javax.xml.namespace.QName COUNTRANGE$14 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "CountRange");
        private static final javax.xml.namespace.QName TIMERANGE$16 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "TimeRange");
        private static final javax.xml.namespace.QName ABSTRACTDATARECORD$18 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "AbstractDataRecord");
        private static final org.apache.xmlbeans.QNameSet ABSTRACTDATARECORD$19 = org.apache.xmlbeans.QNameSet.forArray( new javax.xml.namespace.QName[] { 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "SimpleDataRecord"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "DataRecord"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "NormalizedCurve"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "AbstractDataRecord"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Envelope"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "ConditionalValue"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Vector"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "GeoLocationArea"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "ConditionalData"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Position"),
        });
        private static final javax.xml.namespace.QName ABSTRACTDATAARRAY1$20 = 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "AbstractDataArray");
        private static final org.apache.xmlbeans.QNameSet ABSTRACTDATAARRAY1$21 = org.apache.xmlbeans.QNameSet.forArray( new javax.xml.namespace.QName[] { 
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "Curve"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "DataArray"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "AbstractDataArray"),
            new javax.xml.namespace.QName("http://www.opengis.net/swe/1.0", "SquareMatrix"),
        });
        private static final javax.xml.namespace.QName NAME$22 = 
            new javax.xml.namespace.QName("", "name");
        private static final javax.xml.namespace.QName TYPE$24 = 
            new javax.xml.namespace.QName("http://www.w3.org/1999/xlink", "type");
        private static final javax.xml.namespace.QName HREF$26 = 
            new javax.xml.namespace.QName("http://www.w3.org/1999/xlink", "href");
        private static final javax.xml.namespace.QName ROLE$28 = 
            new javax.xml.namespace.QName("http://www.w3.org/1999/xlink", "role");
        private static final javax.xml.namespace.QName ARCROLE$30 = 
            new javax.xml.namespace.QName("http://www.w3.org/1999/xlink", "arcrole");
        private static final javax.xml.namespace.QName TITLE$32 = 
            new javax.xml.namespace.QName("http://www.w3.org/1999/xlink", "title");
        private static final javax.xml.namespace.QName SHOW$34 = 
            new javax.xml.namespace.QName("http://www.w3.org/1999/xlink", "show");
        private static final javax.xml.namespace.QName ACTUATE$36 = 
            new javax.xml.namespace.QName("http://www.w3.org/1999/xlink", "actuate");
        private static final javax.xml.namespace.QName REMOTESCHEMA$38 = 
            new javax.xml.namespace.QName("http://www.opengis.net/gml", "remoteSchema");
        
        
        /**
         * Gets the "Count" element
         */
        public net.opengis.swe.x10.CountDocument.Count getCount()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.CountDocument.Count target = null;
                target = (net.opengis.swe.x10.CountDocument.Count)get_store().find_element_user(COUNT$0, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Count" element
         */
        public boolean isSetCount()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(COUNT$0) != 0;
            }
        }
        
        /**
         * Sets the "Count" element
         */
        public void setCount(net.opengis.swe.x10.CountDocument.Count count)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.CountDocument.Count target = null;
                target = (net.opengis.swe.x10.CountDocument.Count)get_store().find_element_user(COUNT$0, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.CountDocument.Count)get_store().add_element_user(COUNT$0);
                }
                target.set(count);
            }
        }
        
        /**
         * Appends and returns a new empty "Count" element
         */
        public net.opengis.swe.x10.CountDocument.Count addNewCount()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.CountDocument.Count target = null;
                target = (net.opengis.swe.x10.CountDocument.Count)get_store().add_element_user(COUNT$0);
                return target;
            }
        }
        
        /**
         * Unsets the "Count" element
         */
        public void unsetCount()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(COUNT$0, 0);
            }
        }
        
        /**
         * Gets the "Quantity" element
         */
        public net.opengis.swe.x10.QuantityDocument.Quantity getQuantity()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.QuantityDocument.Quantity target = null;
                target = (net.opengis.swe.x10.QuantityDocument.Quantity)get_store().find_element_user(QUANTITY$2, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Quantity" element
         */
        public boolean isSetQuantity()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(QUANTITY$2) != 0;
            }
        }
        
        /**
         * Sets the "Quantity" element
         */
        public void setQuantity(net.opengis.swe.x10.QuantityDocument.Quantity quantity)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.QuantityDocument.Quantity target = null;
                target = (net.opengis.swe.x10.QuantityDocument.Quantity)get_store().find_element_user(QUANTITY$2, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.QuantityDocument.Quantity)get_store().add_element_user(QUANTITY$2);
                }
                target.set(quantity);
            }
        }
        
        /**
         * Appends and returns a new empty "Quantity" element
         */
        public net.opengis.swe.x10.QuantityDocument.Quantity addNewQuantity()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.QuantityDocument.Quantity target = null;
                target = (net.opengis.swe.x10.QuantityDocument.Quantity)get_store().add_element_user(QUANTITY$2);
                return target;
            }
        }
        
        /**
         * Unsets the "Quantity" element
         */
        public void unsetQuantity()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(QUANTITY$2, 0);
            }
        }
        
        /**
         * Gets the "Time" element
         */
        public net.opengis.swe.x10.TimeDocument.Time getTime()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.TimeDocument.Time target = null;
                target = (net.opengis.swe.x10.TimeDocument.Time)get_store().find_element_user(TIME$4, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Time" element
         */
        public boolean isSetTime()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(TIME$4) != 0;
            }
        }
        
        /**
         * Sets the "Time" element
         */
        public void setTime(net.opengis.swe.x10.TimeDocument.Time time)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.TimeDocument.Time target = null;
                target = (net.opengis.swe.x10.TimeDocument.Time)get_store().find_element_user(TIME$4, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.TimeDocument.Time)get_store().add_element_user(TIME$4);
                }
                target.set(time);
            }
        }
        
        /**
         * Appends and returns a new empty "Time" element
         */
        public net.opengis.swe.x10.TimeDocument.Time addNewTime()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.TimeDocument.Time target = null;
                target = (net.opengis.swe.x10.TimeDocument.Time)get_store().add_element_user(TIME$4);
                return target;
            }
        }
        
        /**
         * Unsets the "Time" element
         */
        public void unsetTime()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(TIME$4, 0);
            }
        }
        
        /**
         * Gets the "Boolean" element
         */
        public net.opengis.swe.x10.BooleanDocument.Boolean getBoolean()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.BooleanDocument.Boolean target = null;
                target = (net.opengis.swe.x10.BooleanDocument.Boolean)get_store().find_element_user(BOOLEAN$6, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Boolean" element
         */
        public boolean isSetBoolean()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(BOOLEAN$6) != 0;
            }
        }
        
        /**
         * Sets the "Boolean" element
         */
        public void setBoolean(net.opengis.swe.x10.BooleanDocument.Boolean xboolean)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.BooleanDocument.Boolean target = null;
                target = (net.opengis.swe.x10.BooleanDocument.Boolean)get_store().find_element_user(BOOLEAN$6, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.BooleanDocument.Boolean)get_store().add_element_user(BOOLEAN$6);
                }
                target.set(xboolean);
            }
        }
        
        /**
         * Appends and returns a new empty "Boolean" element
         */
        public net.opengis.swe.x10.BooleanDocument.Boolean addNewBoolean()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.BooleanDocument.Boolean target = null;
                target = (net.opengis.swe.x10.BooleanDocument.Boolean)get_store().add_element_user(BOOLEAN$6);
                return target;
            }
        }
        
        /**
         * Unsets the "Boolean" element
         */
        public void unsetBoolean()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(BOOLEAN$6, 0);
            }
        }
        
        /**
         * Gets the "Category" element
         */
        public net.opengis.swe.x10.CategoryDocument.Category getCategory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.CategoryDocument.Category target = null;
                target = (net.opengis.swe.x10.CategoryDocument.Category)get_store().find_element_user(CATEGORY$8, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Category" element
         */
        public boolean isSetCategory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(CATEGORY$8) != 0;
            }
        }
        
        /**
         * Sets the "Category" element
         */
        public void setCategory(net.opengis.swe.x10.CategoryDocument.Category category)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.CategoryDocument.Category target = null;
                target = (net.opengis.swe.x10.CategoryDocument.Category)get_store().find_element_user(CATEGORY$8, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.CategoryDocument.Category)get_store().add_element_user(CATEGORY$8);
                }
                target.set(category);
            }
        }
        
        /**
         * Appends and returns a new empty "Category" element
         */
        public net.opengis.swe.x10.CategoryDocument.Category addNewCategory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.CategoryDocument.Category target = null;
                target = (net.opengis.swe.x10.CategoryDocument.Category)get_store().add_element_user(CATEGORY$8);
                return target;
            }
        }
        
        /**
         * Unsets the "Category" element
         */
        public void unsetCategory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(CATEGORY$8, 0);
            }
        }
        
        /**
         * Gets the "Text" element
         */
        public net.opengis.swe.x10.TextDocument.Text getText()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.TextDocument.Text target = null;
                target = (net.opengis.swe.x10.TextDocument.Text)get_store().find_element_user(TEXT$10, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Text" element
         */
        public boolean isSetText()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(TEXT$10) != 0;
            }
        }
        
        /**
         * Sets the "Text" element
         */
        public void setText(net.opengis.swe.x10.TextDocument.Text text)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.TextDocument.Text target = null;
                target = (net.opengis.swe.x10.TextDocument.Text)get_store().find_element_user(TEXT$10, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.TextDocument.Text)get_store().add_element_user(TEXT$10);
                }
                target.set(text);
            }
        }
        
        /**
         * Appends and returns a new empty "Text" element
         */
        public net.opengis.swe.x10.TextDocument.Text addNewText()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.TextDocument.Text target = null;
                target = (net.opengis.swe.x10.TextDocument.Text)get_store().add_element_user(TEXT$10);
                return target;
            }
        }
        
        /**
         * Unsets the "Text" element
         */
        public void unsetText()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(TEXT$10, 0);
            }
        }
        
        /**
         * Gets the "QuantityRange" element
         */
        public net.opengis.swe.x10.QuantityRangeDocument.QuantityRange getQuantityRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.QuantityRangeDocument.QuantityRange target = null;
                target = (net.opengis.swe.x10.QuantityRangeDocument.QuantityRange)get_store().find_element_user(QUANTITYRANGE$12, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "QuantityRange" element
         */
        public boolean isSetQuantityRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(QUANTITYRANGE$12) != 0;
            }
        }
        
        /**
         * Sets the "QuantityRange" element
         */
        public void setQuantityRange(net.opengis.swe.x10.QuantityRangeDocument.QuantityRange quantityRange)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.QuantityRangeDocument.QuantityRange target = null;
                target = (net.opengis.swe.x10.QuantityRangeDocument.QuantityRange)get_store().find_element_user(QUANTITYRANGE$12, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.QuantityRangeDocument.QuantityRange)get_store().add_element_user(QUANTITYRANGE$12);
                }
                target.set(quantityRange);
            }
        }
        
        /**
         * Appends and returns a new empty "QuantityRange" element
         */
        public net.opengis.swe.x10.QuantityRangeDocument.QuantityRange addNewQuantityRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.QuantityRangeDocument.QuantityRange target = null;
                target = (net.opengis.swe.x10.QuantityRangeDocument.QuantityRange)get_store().add_element_user(QUANTITYRANGE$12);
                return target;
            }
        }
        
        /**
         * Unsets the "QuantityRange" element
         */
        public void unsetQuantityRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(QUANTITYRANGE$12, 0);
            }
        }
        
        /**
         * Gets the "CountRange" element
         */
        public net.opengis.swe.x10.CountRangeDocument.CountRange getCountRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.CountRangeDocument.CountRange target = null;
                target = (net.opengis.swe.x10.CountRangeDocument.CountRange)get_store().find_element_user(COUNTRANGE$14, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "CountRange" element
         */
        public boolean isSetCountRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(COUNTRANGE$14) != 0;
            }
        }
        
        /**
         * Sets the "CountRange" element
         */
        public void setCountRange(net.opengis.swe.x10.CountRangeDocument.CountRange countRange)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.CountRangeDocument.CountRange target = null;
                target = (net.opengis.swe.x10.CountRangeDocument.CountRange)get_store().find_element_user(COUNTRANGE$14, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.CountRangeDocument.CountRange)get_store().add_element_user(COUNTRANGE$14);
                }
                target.set(countRange);
            }
        }
        
        /**
         * Appends and returns a new empty "CountRange" element
         */
        public net.opengis.swe.x10.CountRangeDocument.CountRange addNewCountRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.CountRangeDocument.CountRange target = null;
                target = (net.opengis.swe.x10.CountRangeDocument.CountRange)get_store().add_element_user(COUNTRANGE$14);
                return target;
            }
        }
        
        /**
         * Unsets the "CountRange" element
         */
        public void unsetCountRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(COUNTRANGE$14, 0);
            }
        }
        
        /**
         * Gets the "TimeRange" element
         */
        public net.opengis.swe.x10.TimeRangeDocument.TimeRange getTimeRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.TimeRangeDocument.TimeRange target = null;
                target = (net.opengis.swe.x10.TimeRangeDocument.TimeRange)get_store().find_element_user(TIMERANGE$16, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TimeRange" element
         */
        public boolean isSetTimeRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(TIMERANGE$16) != 0;
            }
        }
        
        /**
         * Sets the "TimeRange" element
         */
        public void setTimeRange(net.opengis.swe.x10.TimeRangeDocument.TimeRange timeRange)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.TimeRangeDocument.TimeRange target = null;
                target = (net.opengis.swe.x10.TimeRangeDocument.TimeRange)get_store().find_element_user(TIMERANGE$16, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.TimeRangeDocument.TimeRange)get_store().add_element_user(TIMERANGE$16);
                }
                target.set(timeRange);
            }
        }
        
        /**
         * Appends and returns a new empty "TimeRange" element
         */
        public net.opengis.swe.x10.TimeRangeDocument.TimeRange addNewTimeRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.TimeRangeDocument.TimeRange target = null;
                target = (net.opengis.swe.x10.TimeRangeDocument.TimeRange)get_store().add_element_user(TIMERANGE$16);
                return target;
            }
        }
        
        /**
         * Unsets the "TimeRange" element
         */
        public void unsetTimeRange()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(TIMERANGE$16, 0);
            }
        }
        
        /**
         * Gets the "AbstractDataRecord" element
         */
        public net.opengis.swe.x10.AbstractDataRecordType getAbstractDataRecord()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.AbstractDataRecordType target = null;
                target = (net.opengis.swe.x10.AbstractDataRecordType)get_store().find_element_user(ABSTRACTDATARECORD$19, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "AbstractDataRecord" element
         */
        public boolean isSetAbstractDataRecord()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(ABSTRACTDATARECORD$19) != 0;
            }
        }
        
        /**
         * Sets the "AbstractDataRecord" element
         */
        public void setAbstractDataRecord(net.opengis.swe.x10.AbstractDataRecordType abstractDataRecord)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.AbstractDataRecordType target = null;
                target = (net.opengis.swe.x10.AbstractDataRecordType)get_store().find_element_user(ABSTRACTDATARECORD$19, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.AbstractDataRecordType)get_store().add_element_user(ABSTRACTDATARECORD$18);
                }
                target.set(abstractDataRecord);
            }
        }
        
        /**
         * Appends and returns a new empty "AbstractDataRecord" element
         */
        public net.opengis.swe.x10.AbstractDataRecordType addNewAbstractDataRecord()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.AbstractDataRecordType target = null;
                target = (net.opengis.swe.x10.AbstractDataRecordType)get_store().add_element_user(ABSTRACTDATARECORD$18);
                return target;
            }
        }
        
        /**
         * Unsets the "AbstractDataRecord" element
         */
        public void unsetAbstractDataRecord()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(ABSTRACTDATARECORD$19, 0);
            }
        }
        
        /**
         * Gets the "AbstractDataArray" element
         */
        public net.opengis.swe.x10.AbstractDataArrayType getAbstractDataArray1()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.AbstractDataArrayType target = null;
                target = (net.opengis.swe.x10.AbstractDataArrayType)get_store().find_element_user(ABSTRACTDATAARRAY1$21, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "AbstractDataArray" element
         */
        public boolean isSetAbstractDataArray1()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(ABSTRACTDATAARRAY1$21) != 0;
            }
        }
        
        /**
         * Sets the "AbstractDataArray" element
         */
        public void setAbstractDataArray1(net.opengis.swe.x10.AbstractDataArrayType abstractDataArray1)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.AbstractDataArrayType target = null;
                target = (net.opengis.swe.x10.AbstractDataArrayType)get_store().find_element_user(ABSTRACTDATAARRAY1$21, 0);
                if (target == null)
                {
                    target = (net.opengis.swe.x10.AbstractDataArrayType)get_store().add_element_user(ABSTRACTDATAARRAY1$20);
                }
                target.set(abstractDataArray1);
            }
        }
        
        /**
         * Appends and returns a new empty "AbstractDataArray" element
         */
        public net.opengis.swe.x10.AbstractDataArrayType addNewAbstractDataArray1()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.swe.x10.AbstractDataArrayType target = null;
                target = (net.opengis.swe.x10.AbstractDataArrayType)get_store().add_element_user(ABSTRACTDATAARRAY1$20);
                return target;
            }
        }
        
        /**
         * Unsets the "AbstractDataArray" element
         */
        public void unsetAbstractDataArray1()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(ABSTRACTDATAARRAY1$21, 0);
            }
        }
        
        /**
         * Gets the "name" attribute
         */
        public java.lang.String getName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(NAME$22);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "name" attribute
         */
        public org.apache.xmlbeans.XmlToken xgetName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlToken target = null;
                target = (org.apache.xmlbeans.XmlToken)get_store().find_attribute_user(NAME$22);
                return target;
            }
        }
        
        /**
         * Sets the "name" attribute
         */
        public void setName(java.lang.String name)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(NAME$22);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(NAME$22);
                }
                target.setStringValue(name);
            }
        }
        
        /**
         * Sets (as xml) the "name" attribute
         */
        public void xsetName(org.apache.xmlbeans.XmlToken name)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlToken target = null;
                target = (org.apache.xmlbeans.XmlToken)get_store().find_attribute_user(NAME$22);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlToken)get_store().add_attribute_user(NAME$22);
                }
                target.set(name);
            }
        }
        
        /**
         * Gets the "type" attribute
         */
        public org.w3.x1999.xlink.TypeType.Enum getType()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TYPE$24);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_default_attribute_value(TYPE$24);
                }
                if (target == null)
                {
                    return null;
                }
                return (org.w3.x1999.xlink.TypeType.Enum)target.getEnumValue();
            }
        }
        
        /**
         * Gets (as xml) the "type" attribute
         */
        public org.w3.x1999.xlink.TypeType xgetType()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.TypeType target = null;
                target = (org.w3.x1999.xlink.TypeType)get_store().find_attribute_user(TYPE$24);
                if (target == null)
                {
                    target = (org.w3.x1999.xlink.TypeType)get_default_attribute_value(TYPE$24);
                }
                return target;
            }
        }
        
        /**
         * True if has "type" attribute
         */
        public boolean isSetType()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TYPE$24) != null;
            }
        }
        
        /**
         * Sets the "type" attribute
         */
        public void setType(org.w3.x1999.xlink.TypeType.Enum type)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TYPE$24);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(TYPE$24);
                }
                target.setEnumValue(type);
            }
        }
        
        /**
         * Sets (as xml) the "type" attribute
         */
        public void xsetType(org.w3.x1999.xlink.TypeType type)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.TypeType target = null;
                target = (org.w3.x1999.xlink.TypeType)get_store().find_attribute_user(TYPE$24);
                if (target == null)
                {
                    target = (org.w3.x1999.xlink.TypeType)get_store().add_attribute_user(TYPE$24);
                }
                target.set(type);
            }
        }
        
        /**
         * Unsets the "type" attribute
         */
        public void unsetType()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TYPE$24);
            }
        }
        
        /**
         * Gets the "href" attribute
         */
        public java.lang.String getHref()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(HREF$26);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "href" attribute
         */
        public org.w3.x1999.xlink.HrefType xgetHref()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.HrefType target = null;
                target = (org.w3.x1999.xlink.HrefType)get_store().find_attribute_user(HREF$26);
                return target;
            }
        }
        
        /**
         * True if has "href" attribute
         */
        public boolean isSetHref()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(HREF$26) != null;
            }
        }
        
        /**
         * Sets the "href" attribute
         */
        public void setHref(java.lang.String href)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(HREF$26);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(HREF$26);
                }
                target.setStringValue(href);
            }
        }
        
        /**
         * Sets (as xml) the "href" attribute
         */
        public void xsetHref(org.w3.x1999.xlink.HrefType href)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.HrefType target = null;
                target = (org.w3.x1999.xlink.HrefType)get_store().find_attribute_user(HREF$26);
                if (target == null)
                {
                    target = (org.w3.x1999.xlink.HrefType)get_store().add_attribute_user(HREF$26);
                }
                target.set(href);
            }
        }
        
        /**
         * Unsets the "href" attribute
         */
        public void unsetHref()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(HREF$26);
            }
        }
        
        /**
         * Gets the "role" attribute
         */
        public java.lang.String getRole()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ROLE$28);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "role" attribute
         */
        public org.w3.x1999.xlink.RoleType xgetRole()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.RoleType target = null;
                target = (org.w3.x1999.xlink.RoleType)get_store().find_attribute_user(ROLE$28);
                return target;
            }
        }
        
        /**
         * True if has "role" attribute
         */
        public boolean isSetRole()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ROLE$28) != null;
            }
        }
        
        /**
         * Sets the "role" attribute
         */
        public void setRole(java.lang.String role)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ROLE$28);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ROLE$28);
                }
                target.setStringValue(role);
            }
        }
        
        /**
         * Sets (as xml) the "role" attribute
         */
        public void xsetRole(org.w3.x1999.xlink.RoleType role)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.RoleType target = null;
                target = (org.w3.x1999.xlink.RoleType)get_store().find_attribute_user(ROLE$28);
                if (target == null)
                {
                    target = (org.w3.x1999.xlink.RoleType)get_store().add_attribute_user(ROLE$28);
                }
                target.set(role);
            }
        }
        
        /**
         * Unsets the "role" attribute
         */
        public void unsetRole()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ROLE$28);
            }
        }
        
        /**
         * Gets the "arcrole" attribute
         */
        public java.lang.String getArcrole()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ARCROLE$30);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "arcrole" attribute
         */
        public org.w3.x1999.xlink.ArcroleType xgetArcrole()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.ArcroleType target = null;
                target = (org.w3.x1999.xlink.ArcroleType)get_store().find_attribute_user(ARCROLE$30);
                return target;
            }
        }
        
        /**
         * True if has "arcrole" attribute
         */
        public boolean isSetArcrole()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ARCROLE$30) != null;
            }
        }
        
        /**
         * Sets the "arcrole" attribute
         */
        public void setArcrole(java.lang.String arcrole)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ARCROLE$30);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ARCROLE$30);
                }
                target.setStringValue(arcrole);
            }
        }
        
        /**
         * Sets (as xml) the "arcrole" attribute
         */
        public void xsetArcrole(org.w3.x1999.xlink.ArcroleType arcrole)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.ArcroleType target = null;
                target = (org.w3.x1999.xlink.ArcroleType)get_store().find_attribute_user(ARCROLE$30);
                if (target == null)
                {
                    target = (org.w3.x1999.xlink.ArcroleType)get_store().add_attribute_user(ARCROLE$30);
                }
                target.set(arcrole);
            }
        }
        
        /**
         * Unsets the "arcrole" attribute
         */
        public void unsetArcrole()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ARCROLE$30);
            }
        }
        
        /**
         * Gets the "title" attribute
         */
        public java.lang.String getTitle()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TITLE$32);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "title" attribute
         */
        public org.w3.x1999.xlink.TitleAttrType xgetTitle()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.TitleAttrType target = null;
                target = (org.w3.x1999.xlink.TitleAttrType)get_store().find_attribute_user(TITLE$32);
                return target;
            }
        }
        
        /**
         * True if has "title" attribute
         */
        public boolean isSetTitle()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TITLE$32) != null;
            }
        }
        
        /**
         * Sets the "title" attribute
         */
        public void setTitle(java.lang.String title)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TITLE$32);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(TITLE$32);
                }
                target.setStringValue(title);
            }
        }
        
        /**
         * Sets (as xml) the "title" attribute
         */
        public void xsetTitle(org.w3.x1999.xlink.TitleAttrType title)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.TitleAttrType target = null;
                target = (org.w3.x1999.xlink.TitleAttrType)get_store().find_attribute_user(TITLE$32);
                if (target == null)
                {
                    target = (org.w3.x1999.xlink.TitleAttrType)get_store().add_attribute_user(TITLE$32);
                }
                target.set(title);
            }
        }
        
        /**
         * Unsets the "title" attribute
         */
        public void unsetTitle()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TITLE$32);
            }
        }
        
        /**
         * Gets the "show" attribute
         */
        public org.w3.x1999.xlink.ShowType.Enum getShow()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SHOW$34);
                if (target == null)
                {
                    return null;
                }
                return (org.w3.x1999.xlink.ShowType.Enum)target.getEnumValue();
            }
        }
        
        /**
         * Gets (as xml) the "show" attribute
         */
        public org.w3.x1999.xlink.ShowType xgetShow()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.ShowType target = null;
                target = (org.w3.x1999.xlink.ShowType)get_store().find_attribute_user(SHOW$34);
                return target;
            }
        }
        
        /**
         * True if has "show" attribute
         */
        public boolean isSetShow()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SHOW$34) != null;
            }
        }
        
        /**
         * Sets the "show" attribute
         */
        public void setShow(org.w3.x1999.xlink.ShowType.Enum show)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SHOW$34);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SHOW$34);
                }
                target.setEnumValue(show);
            }
        }
        
        /**
         * Sets (as xml) the "show" attribute
         */
        public void xsetShow(org.w3.x1999.xlink.ShowType show)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.ShowType target = null;
                target = (org.w3.x1999.xlink.ShowType)get_store().find_attribute_user(SHOW$34);
                if (target == null)
                {
                    target = (org.w3.x1999.xlink.ShowType)get_store().add_attribute_user(SHOW$34);
                }
                target.set(show);
            }
        }
        
        /**
         * Unsets the "show" attribute
         */
        public void unsetShow()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SHOW$34);
            }
        }
        
        /**
         * Gets the "actuate" attribute
         */
        public org.w3.x1999.xlink.ActuateType.Enum getActuate()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ACTUATE$36);
                if (target == null)
                {
                    return null;
                }
                return (org.w3.x1999.xlink.ActuateType.Enum)target.getEnumValue();
            }
        }
        
        /**
         * Gets (as xml) the "actuate" attribute
         */
        public org.w3.x1999.xlink.ActuateType xgetActuate()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.ActuateType target = null;
                target = (org.w3.x1999.xlink.ActuateType)get_store().find_attribute_user(ACTUATE$36);
                return target;
            }
        }
        
        /**
         * True if has "actuate" attribute
         */
        public boolean isSetActuate()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ACTUATE$36) != null;
            }
        }
        
        /**
         * Sets the "actuate" attribute
         */
        public void setActuate(org.w3.x1999.xlink.ActuateType.Enum actuate)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ACTUATE$36);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ACTUATE$36);
                }
                target.setEnumValue(actuate);
            }
        }
        
        /**
         * Sets (as xml) the "actuate" attribute
         */
        public void xsetActuate(org.w3.x1999.xlink.ActuateType actuate)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.w3.x1999.xlink.ActuateType target = null;
                target = (org.w3.x1999.xlink.ActuateType)get_store().find_attribute_user(ACTUATE$36);
                if (target == null)
                {
                    target = (org.w3.x1999.xlink.ActuateType)get_store().add_attribute_user(ACTUATE$36);
                }
                target.set(actuate);
            }
        }
        
        /**
         * Unsets the "actuate" attribute
         */
        public void unsetActuate()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ACTUATE$36);
            }
        }
        
        /**
         * Gets the "remoteSchema" attribute
         */
        public java.lang.String getRemoteSchema()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(REMOTESCHEMA$38);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "remoteSchema" attribute
         */
        public org.apache.xmlbeans.XmlAnyURI xgetRemoteSchema()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnyURI target = null;
                target = (org.apache.xmlbeans.XmlAnyURI)get_store().find_attribute_user(REMOTESCHEMA$38);
                return target;
            }
        }
        
        /**
         * True if has "remoteSchema" attribute
         */
        public boolean isSetRemoteSchema()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(REMOTESCHEMA$38) != null;
            }
        }
        
        /**
         * Sets the "remoteSchema" attribute
         */
        public void setRemoteSchema(java.lang.String remoteSchema)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(REMOTESCHEMA$38);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(REMOTESCHEMA$38);
                }
                target.setStringValue(remoteSchema);
            }
        }
        
        /**
         * Sets (as xml) the "remoteSchema" attribute
         */
        public void xsetRemoteSchema(org.apache.xmlbeans.XmlAnyURI remoteSchema)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnyURI target = null;
                target = (org.apache.xmlbeans.XmlAnyURI)get_store().find_attribute_user(REMOTESCHEMA$38);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnyURI)get_store().add_attribute_user(REMOTESCHEMA$38);
                }
                target.set(remoteSchema);
            }
        }
        
        /**
         * Unsets the "remoteSchema" attribute
         */
        public void unsetRemoteSchema()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(REMOTESCHEMA$38);
            }
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy