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

net.opengis.sensorml.x20.impl.AbstractProcessTypeImpl Maven / Gradle / Ivy

There is a newer version: 2.7.0
Show newest version
/*
 * XML Type:  AbstractProcessType
 * Namespace: http://www.opengis.net/sensorml/2.0
 * Java type: net.opengis.sensorml.x20.AbstractProcessType
 *
 * Automatically generated - do not modify.
 */
package net.opengis.sensorml.x20.impl;
/**
 * An XML AbstractProcessType(@http://www.opengis.net/sensorml/2.0).
 *
 * This is a complex type.
 */
public class AbstractProcessTypeImpl extends net.opengis.sensorml.x20.impl.DescribedObjectTypeImpl implements net.opengis.sensorml.x20.AbstractProcessType
{
    private static final long serialVersionUID = 1L;
    
    public AbstractProcessTypeImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName TYPEOF$0 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "typeOf");
    private static final javax.xml.namespace.QName CONFIGURATION$2 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "configuration");
    private static final javax.xml.namespace.QName FEATURESOFINTEREST$4 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "featuresOfInterest");
    private static final javax.xml.namespace.QName INPUTS$6 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "inputs");
    private static final javax.xml.namespace.QName OUTPUTS$8 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "outputs");
    private static final javax.xml.namespace.QName PARAMETERS$10 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "parameters");
    private static final javax.xml.namespace.QName MODES$12 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "modes");
    private static final javax.xml.namespace.QName DEFINITION$14 = 
        new javax.xml.namespace.QName("", "definition");
    
    
    /**
     * Gets the "typeOf" element
     */
    public net.opengis.gml.x32.ReferenceType getTypeOf()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.gml.x32.ReferenceType target = null;
            target = (net.opengis.gml.x32.ReferenceType)get_store().find_element_user(TYPEOF$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "typeOf" element
     */
    public boolean isSetTypeOf()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TYPEOF$0) != 0;
        }
    }
    
    /**
     * Sets the "typeOf" element
     */
    public void setTypeOf(net.opengis.gml.x32.ReferenceType typeOf)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.gml.x32.ReferenceType target = null;
            target = (net.opengis.gml.x32.ReferenceType)get_store().find_element_user(TYPEOF$0, 0);
            if (target == null)
            {
                target = (net.opengis.gml.x32.ReferenceType)get_store().add_element_user(TYPEOF$0);
            }
            target.set(typeOf);
        }
    }
    
    /**
     * Appends and returns a new empty "typeOf" element
     */
    public net.opengis.gml.x32.ReferenceType addNewTypeOf()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.gml.x32.ReferenceType target = null;
            target = (net.opengis.gml.x32.ReferenceType)get_store().add_element_user(TYPEOF$0);
            return target;
        }
    }
    
    /**
     * Unsets the "typeOf" element
     */
    public void unsetTypeOf()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TYPEOF$0, 0);
        }
    }
    
    /**
     * Gets the "configuration" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Configuration getConfiguration()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Configuration target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Configuration)get_store().find_element_user(CONFIGURATION$2, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "configuration" element
     */
    public boolean isSetConfiguration()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CONFIGURATION$2) != 0;
        }
    }
    
    /**
     * Sets the "configuration" element
     */
    public void setConfiguration(net.opengis.sensorml.x20.AbstractProcessType.Configuration configuration)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Configuration target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Configuration)get_store().find_element_user(CONFIGURATION$2, 0);
            if (target == null)
            {
                target = (net.opengis.sensorml.x20.AbstractProcessType.Configuration)get_store().add_element_user(CONFIGURATION$2);
            }
            target.set(configuration);
        }
    }
    
    /**
     * Appends and returns a new empty "configuration" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Configuration addNewConfiguration()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Configuration target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Configuration)get_store().add_element_user(CONFIGURATION$2);
            return target;
        }
    }
    
    /**
     * Unsets the "configuration" element
     */
    public void unsetConfiguration()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CONFIGURATION$2, 0);
        }
    }
    
    /**
     * Gets the "featuresOfInterest" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest getFeaturesOfInterest()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest)get_store().find_element_user(FEATURESOFINTEREST$4, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "featuresOfInterest" element
     */
    public boolean isSetFeaturesOfInterest()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(FEATURESOFINTEREST$4) != 0;
        }
    }
    
    /**
     * Sets the "featuresOfInterest" element
     */
    public void setFeaturesOfInterest(net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest featuresOfInterest)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest)get_store().find_element_user(FEATURESOFINTEREST$4, 0);
            if (target == null)
            {
                target = (net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest)get_store().add_element_user(FEATURESOFINTEREST$4);
            }
            target.set(featuresOfInterest);
        }
    }
    
    /**
     * Appends and returns a new empty "featuresOfInterest" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest addNewFeaturesOfInterest()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest)get_store().add_element_user(FEATURESOFINTEREST$4);
            return target;
        }
    }
    
    /**
     * Unsets the "featuresOfInterest" element
     */
    public void unsetFeaturesOfInterest()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(FEATURESOFINTEREST$4, 0);
        }
    }
    
    /**
     * Gets the "inputs" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Inputs getInputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Inputs target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Inputs)get_store().find_element_user(INPUTS$6, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "inputs" element
     */
    public boolean isSetInputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INPUTS$6) != 0;
        }
    }
    
    /**
     * Sets the "inputs" element
     */
    public void setInputs(net.opengis.sensorml.x20.AbstractProcessType.Inputs inputs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Inputs target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Inputs)get_store().find_element_user(INPUTS$6, 0);
            if (target == null)
            {
                target = (net.opengis.sensorml.x20.AbstractProcessType.Inputs)get_store().add_element_user(INPUTS$6);
            }
            target.set(inputs);
        }
    }
    
    /**
     * Appends and returns a new empty "inputs" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Inputs addNewInputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Inputs target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Inputs)get_store().add_element_user(INPUTS$6);
            return target;
        }
    }
    
    /**
     * Unsets the "inputs" element
     */
    public void unsetInputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INPUTS$6, 0);
        }
    }
    
    /**
     * Gets the "outputs" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Outputs getOutputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Outputs target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Outputs)get_store().find_element_user(OUTPUTS$8, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "outputs" element
     */
    public boolean isSetOutputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OUTPUTS$8) != 0;
        }
    }
    
    /**
     * Sets the "outputs" element
     */
    public void setOutputs(net.opengis.sensorml.x20.AbstractProcessType.Outputs outputs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Outputs target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Outputs)get_store().find_element_user(OUTPUTS$8, 0);
            if (target == null)
            {
                target = (net.opengis.sensorml.x20.AbstractProcessType.Outputs)get_store().add_element_user(OUTPUTS$8);
            }
            target.set(outputs);
        }
    }
    
    /**
     * Appends and returns a new empty "outputs" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Outputs addNewOutputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Outputs target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Outputs)get_store().add_element_user(OUTPUTS$8);
            return target;
        }
    }
    
    /**
     * Unsets the "outputs" element
     */
    public void unsetOutputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OUTPUTS$8, 0);
        }
    }
    
    /**
     * Gets the "parameters" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Parameters getParameters()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Parameters target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Parameters)get_store().find_element_user(PARAMETERS$10, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "parameters" element
     */
    public boolean isSetParameters()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PARAMETERS$10) != 0;
        }
    }
    
    /**
     * Sets the "parameters" element
     */
    public void setParameters(net.opengis.sensorml.x20.AbstractProcessType.Parameters parameters)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Parameters target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Parameters)get_store().find_element_user(PARAMETERS$10, 0);
            if (target == null)
            {
                target = (net.opengis.sensorml.x20.AbstractProcessType.Parameters)get_store().add_element_user(PARAMETERS$10);
            }
            target.set(parameters);
        }
    }
    
    /**
     * Appends and returns a new empty "parameters" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Parameters addNewParameters()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Parameters target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Parameters)get_store().add_element_user(PARAMETERS$10);
            return target;
        }
    }
    
    /**
     * Unsets the "parameters" element
     */
    public void unsetParameters()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PARAMETERS$10, 0);
        }
    }
    
    /**
     * Gets array of all "modes" elements
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Modes[] getModesArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(MODES$12, targetList);
            net.opengis.sensorml.x20.AbstractProcessType.Modes[] result = new net.opengis.sensorml.x20.AbstractProcessType.Modes[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "modes" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Modes getModesArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Modes target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Modes)get_store().find_element_user(MODES$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "modes" element
     */
    public int sizeOfModesArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MODES$12);
        }
    }
    
    /**
     * Sets array of all "modes" element
     */
    public void setModesArray(net.opengis.sensorml.x20.AbstractProcessType.Modes[] modesArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(modesArray, MODES$12);
        }
    }
    
    /**
     * Sets ith "modes" element
     */
    public void setModesArray(int i, net.opengis.sensorml.x20.AbstractProcessType.Modes modes)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Modes target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Modes)get_store().find_element_user(MODES$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(modes);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "modes" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Modes insertNewModes(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Modes target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Modes)get_store().insert_element_user(MODES$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "modes" element
     */
    public net.opengis.sensorml.x20.AbstractProcessType.Modes addNewModes()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.AbstractProcessType.Modes target = null;
            target = (net.opengis.sensorml.x20.AbstractProcessType.Modes)get_store().add_element_user(MODES$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "modes" element
     */
    public void removeModes(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MODES$12, i);
        }
    }
    
    /**
     * Gets the "definition" attribute
     */
    public java.lang.String getDefinition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFINITION$14);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "definition" attribute
     */
    public org.apache.xmlbeans.XmlAnyURI xgetDefinition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlAnyURI target = null;
            target = (org.apache.xmlbeans.XmlAnyURI)get_store().find_attribute_user(DEFINITION$14);
            return target;
        }
    }
    
    /**
     * True if has "definition" attribute
     */
    public boolean isSetDefinition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(DEFINITION$14) != null;
        }
    }
    
    /**
     * Sets the "definition" attribute
     */
    public void setDefinition(java.lang.String definition)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFINITION$14);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(DEFINITION$14);
            }
            target.setStringValue(definition);
        }
    }
    
    /**
     * Sets (as xml) the "definition" attribute
     */
    public void xsetDefinition(org.apache.xmlbeans.XmlAnyURI definition)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlAnyURI target = null;
            target = (org.apache.xmlbeans.XmlAnyURI)get_store().find_attribute_user(DEFINITION$14);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlAnyURI)get_store().add_attribute_user(DEFINITION$14);
            }
            target.set(definition);
        }
    }
    
    /**
     * Unsets the "definition" attribute
     */
    public void unsetDefinition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(DEFINITION$14);
        }
    }
    /**
     * An XML configuration(@http://www.opengis.net/sensorml/2.0).
     *
     * This is a complex type.
     */
    public static class ConfigurationImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorml.x20.AbstractProcessType.Configuration
    {
        private static final long serialVersionUID = 1L;
        
        public ConfigurationImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName ABSTRACTSETTINGS$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "AbstractSettings");
        private static final org.apache.xmlbeans.QNameSet ABSTRACTSETTINGS$1 = org.apache.xmlbeans.QNameSet.forArray( new javax.xml.namespace.QName[] { 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "AbstractSettings"),
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "Settings"),
        });
        
        
        /**
         * Gets the "AbstractSettings" element
         */
        public net.opengis.sensorml.x20.AbstractSettingsType getAbstractSettings()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.AbstractSettingsType target = null;
                target = (net.opengis.sensorml.x20.AbstractSettingsType)get_store().find_element_user(ABSTRACTSETTINGS$1, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * Sets the "AbstractSettings" element
         */
        public void setAbstractSettings(net.opengis.sensorml.x20.AbstractSettingsType abstractSettings)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.AbstractSettingsType target = null;
                target = (net.opengis.sensorml.x20.AbstractSettingsType)get_store().find_element_user(ABSTRACTSETTINGS$1, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorml.x20.AbstractSettingsType)get_store().add_element_user(ABSTRACTSETTINGS$0);
                }
                target.set(abstractSettings);
            }
        }
        
        /**
         * Appends and returns a new empty "AbstractSettings" element
         */
        public net.opengis.sensorml.x20.AbstractSettingsType addNewAbstractSettings()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.AbstractSettingsType target = null;
                target = (net.opengis.sensorml.x20.AbstractSettingsType)get_store().add_element_user(ABSTRACTSETTINGS$0);
                return target;
            }
        }
    }
    /**
     * An XML featuresOfInterest(@http://www.opengis.net/sensorml/2.0).
     *
     * This is a complex type.
     */
    public static class FeaturesOfInterestImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorml.x20.AbstractProcessType.FeaturesOfInterest
    {
        private static final long serialVersionUID = 1L;
        
        public FeaturesOfInterestImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName FEATURELIST$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "FeatureList");
        
        
        /**
         * Gets the "FeatureList" element
         */
        public net.opengis.sensorml.x20.FeatureListType getFeatureList()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.FeatureListType target = null;
                target = (net.opengis.sensorml.x20.FeatureListType)get_store().find_element_user(FEATURELIST$0, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * Sets the "FeatureList" element
         */
        public void setFeatureList(net.opengis.sensorml.x20.FeatureListType featureList)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.FeatureListType target = null;
                target = (net.opengis.sensorml.x20.FeatureListType)get_store().find_element_user(FEATURELIST$0, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorml.x20.FeatureListType)get_store().add_element_user(FEATURELIST$0);
                }
                target.set(featureList);
            }
        }
        
        /**
         * Appends and returns a new empty "FeatureList" element
         */
        public net.opengis.sensorml.x20.FeatureListType addNewFeatureList()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.FeatureListType target = null;
                target = (net.opengis.sensorml.x20.FeatureListType)get_store().add_element_user(FEATURELIST$0);
                return target;
            }
        }
    }
    /**
     * An XML inputs(@http://www.opengis.net/sensorml/2.0).
     *
     * This is a complex type.
     */
    public static class InputsImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorml.x20.AbstractProcessType.Inputs
    {
        private static final long serialVersionUID = 1L;
        
        public InputsImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName INPUTLIST$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "InputList");
        
        
        /**
         * Gets the "InputList" element
         */
        public net.opengis.sensorml.x20.InputListType getInputList()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.InputListType target = null;
                target = (net.opengis.sensorml.x20.InputListType)get_store().find_element_user(INPUTLIST$0, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * Sets the "InputList" element
         */
        public void setInputList(net.opengis.sensorml.x20.InputListType inputList)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.InputListType target = null;
                target = (net.opengis.sensorml.x20.InputListType)get_store().find_element_user(INPUTLIST$0, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorml.x20.InputListType)get_store().add_element_user(INPUTLIST$0);
                }
                target.set(inputList);
            }
        }
        
        /**
         * Appends and returns a new empty "InputList" element
         */
        public net.opengis.sensorml.x20.InputListType addNewInputList()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.InputListType target = null;
                target = (net.opengis.sensorml.x20.InputListType)get_store().add_element_user(INPUTLIST$0);
                return target;
            }
        }
    }
    /**
     * An XML outputs(@http://www.opengis.net/sensorml/2.0).
     *
     * This is a complex type.
     */
    public static class OutputsImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorml.x20.AbstractProcessType.Outputs
    {
        private static final long serialVersionUID = 1L;
        
        public OutputsImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName OUTPUTLIST$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "OutputList");
        
        
        /**
         * Gets the "OutputList" element
         */
        public net.opengis.sensorml.x20.OutputListType getOutputList()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.OutputListType target = null;
                target = (net.opengis.sensorml.x20.OutputListType)get_store().find_element_user(OUTPUTLIST$0, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * Sets the "OutputList" element
         */
        public void setOutputList(net.opengis.sensorml.x20.OutputListType outputList)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.OutputListType target = null;
                target = (net.opengis.sensorml.x20.OutputListType)get_store().find_element_user(OUTPUTLIST$0, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorml.x20.OutputListType)get_store().add_element_user(OUTPUTLIST$0);
                }
                target.set(outputList);
            }
        }
        
        /**
         * Appends and returns a new empty "OutputList" element
         */
        public net.opengis.sensorml.x20.OutputListType addNewOutputList()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.OutputListType target = null;
                target = (net.opengis.sensorml.x20.OutputListType)get_store().add_element_user(OUTPUTLIST$0);
                return target;
            }
        }
    }
    /**
     * An XML parameters(@http://www.opengis.net/sensorml/2.0).
     *
     * This is a complex type.
     */
    public static class ParametersImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorml.x20.AbstractProcessType.Parameters
    {
        private static final long serialVersionUID = 1L;
        
        public ParametersImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName PARAMETERLIST$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "ParameterList");
        
        
        /**
         * Gets the "ParameterList" element
         */
        public net.opengis.sensorml.x20.ParameterListType getParameterList()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.ParameterListType target = null;
                target = (net.opengis.sensorml.x20.ParameterListType)get_store().find_element_user(PARAMETERLIST$0, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * Sets the "ParameterList" element
         */
        public void setParameterList(net.opengis.sensorml.x20.ParameterListType parameterList)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.ParameterListType target = null;
                target = (net.opengis.sensorml.x20.ParameterListType)get_store().find_element_user(PARAMETERLIST$0, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorml.x20.ParameterListType)get_store().add_element_user(PARAMETERLIST$0);
                }
                target.set(parameterList);
            }
        }
        
        /**
         * Appends and returns a new empty "ParameterList" element
         */
        public net.opengis.sensorml.x20.ParameterListType addNewParameterList()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.ParameterListType target = null;
                target = (net.opengis.sensorml.x20.ParameterListType)get_store().add_element_user(PARAMETERLIST$0);
                return target;
            }
        }
    }
    /**
     * An XML modes(@http://www.opengis.net/sensorml/2.0).
     *
     * This is a complex type.
     */
    public static class ModesImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorml.x20.AbstractProcessType.Modes
    {
        private static final long serialVersionUID = 1L;
        
        public ModesImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName ABSTRACTMODES$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "AbstractModes");
        private static final org.apache.xmlbeans.QNameSet ABSTRACTMODES$1 = org.apache.xmlbeans.QNameSet.forArray( new javax.xml.namespace.QName[] { 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "ModeChoice"),
            new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "AbstractModes"),
        });
        
        
        /**
         * Gets the "AbstractModes" element
         */
        public net.opengis.sensorml.x20.AbstractModesType getAbstractModes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.AbstractModesType target = null;
                target = (net.opengis.sensorml.x20.AbstractModesType)get_store().find_element_user(ABSTRACTMODES$1, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * Sets the "AbstractModes" element
         */
        public void setAbstractModes(net.opengis.sensorml.x20.AbstractModesType abstractModes)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.AbstractModesType target = null;
                target = (net.opengis.sensorml.x20.AbstractModesType)get_store().find_element_user(ABSTRACTMODES$1, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorml.x20.AbstractModesType)get_store().add_element_user(ABSTRACTMODES$0);
                }
                target.set(abstractModes);
            }
        }
        
        /**
         * Appends and returns a new empty "AbstractModes" element
         */
        public net.opengis.sensorml.x20.AbstractModesType addNewAbstractModes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorml.x20.AbstractModesType target = null;
                target = (net.opengis.sensorml.x20.AbstractModesType)get_store().add_element_user(ABSTRACTMODES$0);
                return target;
            }
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy