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

net.opengis.sps.x10.impl.SubmitRequestResponseDocumentImpl Maven / Gradle / Ivy

There is a newer version: 2.7.0
Show newest version
/*
 * An XML document type.
 * Localname: SubmitRequestResponse
 * Namespace: http://www.opengis.net/sps/1.0
 * Java type: net.opengis.sps.x10.SubmitRequestResponseDocument
 *
 * Automatically generated - do not modify.
 */
package net.opengis.sps.x10.impl;
/**
 * A document containing one SubmitRequestResponse(@http://www.opengis.net/sps/1.0) element.
 *
 * This is a complex type.
 */
public class SubmitRequestResponseDocumentImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sps.x10.SubmitRequestResponseDocument
{
    private static final long serialVersionUID = 1L;
    
    public SubmitRequestResponseDocumentImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName SUBMITREQUESTRESPONSE$0 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sps/1.0", "SubmitRequestResponse");
    
    
    /**
     * Gets the "SubmitRequestResponse" element
     */
    public net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse getSubmitRequestResponse()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse target = null;
            target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse)get_store().find_element_user(SUBMITREQUESTRESPONSE$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * Sets the "SubmitRequestResponse" element
     */
    public void setSubmitRequestResponse(net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse submitRequestResponse)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse target = null;
            target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse)get_store().find_element_user(SUBMITREQUESTRESPONSE$0, 0);
            if (target == null)
            {
                target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse)get_store().add_element_user(SUBMITREQUESTRESPONSE$0);
            }
            target.set(submitRequestResponse);
        }
    }
    
    /**
     * Appends and returns a new empty "SubmitRequestResponse" element
     */
    public net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse addNewSubmitRequestResponse()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse target = null;
            target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse)get_store().add_element_user(SUBMITREQUESTRESPONSE$0);
            return target;
        }
    }
    /**
     * An XML SubmitRequestResponse(@http://www.opengis.net/sps/1.0).
     *
     * This is a complex type.
     */
    public static class SubmitRequestResponseImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse
    {
        private static final long serialVersionUID = 1L;
        
        public SubmitRequestResponseImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName TASKID$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sps/1.0", "taskID");
        private static final javax.xml.namespace.QName STATUS$2 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sps/1.0", "status");
        private static final javax.xml.namespace.QName DESCRIPTION$4 = 
            new javax.xml.namespace.QName("http://www.opengis.net/gml", "description");
        private static final javax.xml.namespace.QName LATESTRESPONSETIME$6 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sps/1.0", "LatestResponseTime");
        private static final javax.xml.namespace.QName ESTIMATEDTOC$8 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sps/1.0", "estimatedToC");
        private static final javax.xml.namespace.QName ALTERNATIVE$10 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sps/1.0", "alternative");
        
        
        /**
         * Gets the "taskID" element
         */
        public java.lang.String getTaskID()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(TASKID$0, 0);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "taskID" element
         */
        public org.apache.xmlbeans.XmlToken xgetTaskID()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlToken target = null;
                target = (org.apache.xmlbeans.XmlToken)get_store().find_element_user(TASKID$0, 0);
                return target;
            }
        }
        
        /**
         * Sets the "taskID" element
         */
        public void setTaskID(java.lang.String taskID)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(TASKID$0, 0);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(TASKID$0);
                }
                target.setStringValue(taskID);
            }
        }
        
        /**
         * Sets (as xml) the "taskID" element
         */
        public void xsetTaskID(org.apache.xmlbeans.XmlToken taskID)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlToken target = null;
                target = (org.apache.xmlbeans.XmlToken)get_store().find_element_user(TASKID$0, 0);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlToken)get_store().add_element_user(TASKID$0);
                }
                target.set(taskID);
            }
        }
        
        /**
         * Gets the "status" element
         */
        public net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status.Enum getStatus()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(STATUS$2, 0);
                if (target == null)
                {
                    return null;
                }
                return (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status.Enum)target.getEnumValue();
            }
        }
        
        /**
         * Gets (as xml) the "status" element
         */
        public net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status xgetStatus()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status target = null;
                target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status)get_store().find_element_user(STATUS$2, 0);
                return target;
            }
        }
        
        /**
         * Sets the "status" element
         */
        public void setStatus(net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status.Enum status)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(STATUS$2, 0);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(STATUS$2);
                }
                target.setEnumValue(status);
            }
        }
        
        /**
         * Sets (as xml) the "status" element
         */
        public void xsetStatus(net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status status)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status target = null;
                target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status)get_store().find_element_user(STATUS$2, 0);
                if (target == null)
                {
                    target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status)get_store().add_element_user(STATUS$2);
                }
                target.set(status);
            }
        }
        
        /**
         * Gets the "description" element
         */
        public net.opengis.gml.StringOrRefType getDescription()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.gml.StringOrRefType target = null;
                target = (net.opengis.gml.StringOrRefType)get_store().find_element_user(DESCRIPTION$4, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "description" element
         */
        public boolean isSetDescription()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(DESCRIPTION$4) != 0;
            }
        }
        
        /**
         * Sets the "description" element
         */
        public void setDescription(net.opengis.gml.StringOrRefType description)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.gml.StringOrRefType target = null;
                target = (net.opengis.gml.StringOrRefType)get_store().find_element_user(DESCRIPTION$4, 0);
                if (target == null)
                {
                    target = (net.opengis.gml.StringOrRefType)get_store().add_element_user(DESCRIPTION$4);
                }
                target.set(description);
            }
        }
        
        /**
         * Appends and returns a new empty "description" element
         */
        public net.opengis.gml.StringOrRefType addNewDescription()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.gml.StringOrRefType target = null;
                target = (net.opengis.gml.StringOrRefType)get_store().add_element_user(DESCRIPTION$4);
                return target;
            }
        }
        
        /**
         * Unsets the "description" element
         */
        public void unsetDescription()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(DESCRIPTION$4, 0);
            }
        }
        
        /**
         * Gets the "LatestResponseTime" element
         */
        public net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime getLatestResponseTime()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime target = null;
                target = (net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime)get_store().find_element_user(LATESTRESPONSETIME$6, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * Sets the "LatestResponseTime" element
         */
        public void setLatestResponseTime(net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime latestResponseTime)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime target = null;
                target = (net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime)get_store().find_element_user(LATESTRESPONSETIME$6, 0);
                if (target == null)
                {
                    target = (net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime)get_store().add_element_user(LATESTRESPONSETIME$6);
                }
                target.set(latestResponseTime);
            }
        }
        
        /**
         * Appends and returns a new empty "LatestResponseTime" element
         */
        public net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime addNewLatestResponseTime()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime target = null;
                target = (net.opengis.sps.x10.LatestResponseTimeDocument.LatestResponseTime)get_store().add_element_user(LATESTRESPONSETIME$6);
                return target;
            }
        }
        
        /**
         * Gets the "estimatedToC" element
         */
        public net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC getEstimatedToC()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC target = null;
                target = (net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC)get_store().find_element_user(ESTIMATEDTOC$8, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "estimatedToC" element
         */
        public boolean isSetEstimatedToC()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(ESTIMATEDTOC$8) != 0;
            }
        }
        
        /**
         * Sets the "estimatedToC" element
         */
        public void setEstimatedToC(net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC estimatedToC)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC target = null;
                target = (net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC)get_store().find_element_user(ESTIMATEDTOC$8, 0);
                if (target == null)
                {
                    target = (net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC)get_store().add_element_user(ESTIMATEDTOC$8);
                }
                target.set(estimatedToC);
            }
        }
        
        /**
         * Appends and returns a new empty "estimatedToC" element
         */
        public net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC addNewEstimatedToC()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC target = null;
                target = (net.opengis.sps.x10.EstimatedToCDocument.EstimatedToC)get_store().add_element_user(ESTIMATEDTOC$8);
                return target;
            }
        }
        
        /**
         * Unsets the "estimatedToC" element
         */
        public void unsetEstimatedToC()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(ESTIMATEDTOC$8, 0);
            }
        }
        
        /**
         * Gets array of all "alternative" elements
         */
        public net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative[] getAlternativeArray()
        {
            synchronized (monitor())
            {
                check_orphaned();
                java.util.List targetList = new java.util.ArrayList();
                get_store().find_all_element_users(ALTERNATIVE$10, targetList);
                net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative[] result = new net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative[targetList.size()];
                targetList.toArray(result);
                return result;
            }
        }
        
        /**
         * Gets ith "alternative" element
         */
        public net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative getAlternativeArray(int i)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative target = null;
                target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative)get_store().find_element_user(ALTERNATIVE$10, i);
                if (target == null)
                {
                    throw new IndexOutOfBoundsException();
                }
                return target;
            }
        }
        
        /**
         * Returns number of "alternative" element
         */
        public int sizeOfAlternativeArray()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(ALTERNATIVE$10);
            }
        }
        
        /**
         * Sets array of all "alternative" element
         */
        public void setAlternativeArray(net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative[] alternativeArray)
        {
            synchronized (monitor())
            {
                check_orphaned();
                arraySetterHelper(alternativeArray, ALTERNATIVE$10);
            }
        }
        
        /**
         * Sets ith "alternative" element
         */
        public void setAlternativeArray(int i, net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative alternative)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative target = null;
                target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative)get_store().find_element_user(ALTERNATIVE$10, i);
                if (target == null)
                {
                    throw new IndexOutOfBoundsException();
                }
                target.set(alternative);
            }
        }
        
        /**
         * Inserts and returns a new empty value (as xml) as the ith "alternative" element
         */
        public net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative insertNewAlternative(int i)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative target = null;
                target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative)get_store().insert_element_user(ALTERNATIVE$10, i);
                return target;
            }
        }
        
        /**
         * Appends and returns a new empty value (as xml) as the last "alternative" element
         */
        public net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative addNewAlternative()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative target = null;
                target = (net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative)get_store().add_element_user(ALTERNATIVE$10);
                return target;
            }
        }
        
        /**
         * Removes the ith "alternative" element
         */
        public void removeAlternative(int i)
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(ALTERNATIVE$10, i);
            }
        }
        /**
         * An XML status(@http://www.opengis.net/sps/1.0).
         *
         * This is an atomic type that is a restriction of net.opengis.sps.x10.SubmitRequestResponseDocument$SubmitRequestResponse$Status.
         */
        public static class StatusImpl extends org.apache.xmlbeans.impl.values.JavaStringEnumerationHolderEx implements net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Status
        {
            private static final long serialVersionUID = 1L;
            
            public StatusImpl(org.apache.xmlbeans.SchemaType sType)
            {
                super(sType, false);
            }
            
            protected StatusImpl(org.apache.xmlbeans.SchemaType sType, boolean b)
            {
                super(sType, b);
            }
        }
        /**
         * An XML alternative(@http://www.opengis.net/sps/1.0).
         *
         * This is a complex type.
         */
        public static class AlternativeImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sps.x10.SubmitRequestResponseDocument.SubmitRequestResponse.Alternative
        {
            private static final long serialVersionUID = 1L;
            
            public AlternativeImpl(org.apache.xmlbeans.SchemaType sType)
            {
                super(sType);
            }
            
            private static final javax.xml.namespace.QName INPUTPARAMETER$0 = 
                new javax.xml.namespace.QName("http://www.opengis.net/sps/1.0", "InputParameter");
            
            
            /**
             * Gets array of all "InputParameter" elements
             */
            public net.opengis.sps.x10.InputParameterType[] getInputParameterArray()
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    java.util.List targetList = new java.util.ArrayList();
                    get_store().find_all_element_users(INPUTPARAMETER$0, targetList);
                    net.opengis.sps.x10.InputParameterType[] result = new net.opengis.sps.x10.InputParameterType[targetList.size()];
                    targetList.toArray(result);
                    return result;
                }
            }
            
            /**
             * Gets ith "InputParameter" element
             */
            public net.opengis.sps.x10.InputParameterType getInputParameterArray(int i)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.sps.x10.InputParameterType target = null;
                    target = (net.opengis.sps.x10.InputParameterType)get_store().find_element_user(INPUTPARAMETER$0, i);
                    if (target == null)
                    {
                      throw new IndexOutOfBoundsException();
                    }
                    return target;
                }
            }
            
            /**
             * Returns number of "InputParameter" element
             */
            public int sizeOfInputParameterArray()
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    return get_store().count_elements(INPUTPARAMETER$0);
                }
            }
            
            /**
             * Sets array of all "InputParameter" element
             */
            public void setInputParameterArray(net.opengis.sps.x10.InputParameterType[] inputParameterArray)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    arraySetterHelper(inputParameterArray, INPUTPARAMETER$0);
                }
            }
            
            /**
             * Sets ith "InputParameter" element
             */
            public void setInputParameterArray(int i, net.opengis.sps.x10.InputParameterType inputParameter)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.sps.x10.InputParameterType target = null;
                    target = (net.opengis.sps.x10.InputParameterType)get_store().find_element_user(INPUTPARAMETER$0, i);
                    if (target == null)
                    {
                      throw new IndexOutOfBoundsException();
                    }
                    target.set(inputParameter);
                }
            }
            
            /**
             * Inserts and returns a new empty value (as xml) as the ith "InputParameter" element
             */
            public net.opengis.sps.x10.InputParameterType insertNewInputParameter(int i)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.sps.x10.InputParameterType target = null;
                    target = (net.opengis.sps.x10.InputParameterType)get_store().insert_element_user(INPUTPARAMETER$0, i);
                    return target;
                }
            }
            
            /**
             * Appends and returns a new empty value (as xml) as the last "InputParameter" element
             */
            public net.opengis.sps.x10.InputParameterType addNewInputParameter()
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.sps.x10.InputParameterType target = null;
                    target = (net.opengis.sps.x10.InputParameterType)get_store().add_element_user(INPUTPARAMETER$0);
                    return target;
                }
            }
            
            /**
             * Removes the ith "InputParameter" element
             */
            public void removeInputParameter(int i)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    get_store().remove_element(INPUTPARAMETER$0, i);
                }
            }
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy