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

net.opengis.sensorML.x10.impl.ComponentArrayTypeImpl Maven / Gradle / Ivy

The newest version!
/*
 * XML Type:  ComponentArrayType
 * Namespace: http://www.opengis.net/sensorML/1.0
 * Java type: net.opengis.sensorML.x10.ComponentArrayType
 *
 * Automatically generated - do not modify.
 */
package net.opengis.sensorML.x10.impl;
/**
 * An XML ComponentArrayType(@http://www.opengis.net/sensorML/1.0).
 *
 * This is a complex type.
 */
public class ComponentArrayTypeImpl extends net.opengis.sensorML.x10.impl.AbstractDerivableComponentTypeImpl implements net.opengis.sensorML.x10.ComponentArrayType
{
    private static final long serialVersionUID = 1L;
    
    public ComponentArrayTypeImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName INPUTS$0 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "inputs");
    private static final javax.xml.namespace.QName OUTPUTS$2 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "outputs");
    private static final javax.xml.namespace.QName PARAMETERS$4 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "parameters");
    private static final javax.xml.namespace.QName COMPONENTS$6 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "components");
    private static final javax.xml.namespace.QName POSITIONS$8 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "positions");
    private static final javax.xml.namespace.QName CONNECTIONS$10 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "connections");
    
    
    /**
     * Gets the "inputs" element
     */
    public net.opengis.sensorML.x10.InputsDocument.Inputs getInputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.InputsDocument.Inputs target = null;
            target = (net.opengis.sensorML.x10.InputsDocument.Inputs)get_store().find_element_user(INPUTS$0, 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$0) != 0;
        }
    }
    
    /**
     * Sets the "inputs" element
     */
    public void setInputs(net.opengis.sensorML.x10.InputsDocument.Inputs inputs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.InputsDocument.Inputs target = null;
            target = (net.opengis.sensorML.x10.InputsDocument.Inputs)get_store().find_element_user(INPUTS$0, 0);
            if (target == null)
            {
                target = (net.opengis.sensorML.x10.InputsDocument.Inputs)get_store().add_element_user(INPUTS$0);
            }
            target.set(inputs);
        }
    }
    
    /**
     * Appends and returns a new empty "inputs" element
     */
    public net.opengis.sensorML.x10.InputsDocument.Inputs addNewInputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.InputsDocument.Inputs target = null;
            target = (net.opengis.sensorML.x10.InputsDocument.Inputs)get_store().add_element_user(INPUTS$0);
            return target;
        }
    }
    
    /**
     * Unsets the "inputs" element
     */
    public void unsetInputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INPUTS$0, 0);
        }
    }
    
    /**
     * Gets the "outputs" element
     */
    public net.opengis.sensorML.x10.OutputsDocument.Outputs getOutputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.OutputsDocument.Outputs target = null;
            target = (net.opengis.sensorML.x10.OutputsDocument.Outputs)get_store().find_element_user(OUTPUTS$2, 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$2) != 0;
        }
    }
    
    /**
     * Sets the "outputs" element
     */
    public void setOutputs(net.opengis.sensorML.x10.OutputsDocument.Outputs outputs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.OutputsDocument.Outputs target = null;
            target = (net.opengis.sensorML.x10.OutputsDocument.Outputs)get_store().find_element_user(OUTPUTS$2, 0);
            if (target == null)
            {
                target = (net.opengis.sensorML.x10.OutputsDocument.Outputs)get_store().add_element_user(OUTPUTS$2);
            }
            target.set(outputs);
        }
    }
    
    /**
     * Appends and returns a new empty "outputs" element
     */
    public net.opengis.sensorML.x10.OutputsDocument.Outputs addNewOutputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.OutputsDocument.Outputs target = null;
            target = (net.opengis.sensorML.x10.OutputsDocument.Outputs)get_store().add_element_user(OUTPUTS$2);
            return target;
        }
    }
    
    /**
     * Unsets the "outputs" element
     */
    public void unsetOutputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OUTPUTS$2, 0);
        }
    }
    
    /**
     * Gets the "parameters" element
     */
    public net.opengis.sensorML.x10.ComponentArrayType.Parameters getParameters()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.ComponentArrayType.Parameters target = null;
            target = (net.opengis.sensorML.x10.ComponentArrayType.Parameters)get_store().find_element_user(PARAMETERS$4, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * Sets the "parameters" element
     */
    public void setParameters(net.opengis.sensorML.x10.ComponentArrayType.Parameters parameters)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.ComponentArrayType.Parameters target = null;
            target = (net.opengis.sensorML.x10.ComponentArrayType.Parameters)get_store().find_element_user(PARAMETERS$4, 0);
            if (target == null)
            {
                target = (net.opengis.sensorML.x10.ComponentArrayType.Parameters)get_store().add_element_user(PARAMETERS$4);
            }
            target.set(parameters);
        }
    }
    
    /**
     * Appends and returns a new empty "parameters" element
     */
    public net.opengis.sensorML.x10.ComponentArrayType.Parameters addNewParameters()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.ComponentArrayType.Parameters target = null;
            target = (net.opengis.sensorML.x10.ComponentArrayType.Parameters)get_store().add_element_user(PARAMETERS$4);
            return target;
        }
    }
    
    /**
     * Gets the "components" element
     */
    public net.opengis.sensorML.x10.ComponentsDocument.Components getComponents()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.ComponentsDocument.Components target = null;
            target = (net.opengis.sensorML.x10.ComponentsDocument.Components)get_store().find_element_user(COMPONENTS$6, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "components" element
     */
    public boolean isSetComponents()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(COMPONENTS$6) != 0;
        }
    }
    
    /**
     * Sets the "components" element
     */
    public void setComponents(net.opengis.sensorML.x10.ComponentsDocument.Components components)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.ComponentsDocument.Components target = null;
            target = (net.opengis.sensorML.x10.ComponentsDocument.Components)get_store().find_element_user(COMPONENTS$6, 0);
            if (target == null)
            {
                target = (net.opengis.sensorML.x10.ComponentsDocument.Components)get_store().add_element_user(COMPONENTS$6);
            }
            target.set(components);
        }
    }
    
    /**
     * Appends and returns a new empty "components" element
     */
    public net.opengis.sensorML.x10.ComponentsDocument.Components addNewComponents()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.ComponentsDocument.Components target = null;
            target = (net.opengis.sensorML.x10.ComponentsDocument.Components)get_store().add_element_user(COMPONENTS$6);
            return target;
        }
    }
    
    /**
     * Unsets the "components" element
     */
    public void unsetComponents()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(COMPONENTS$6, 0);
        }
    }
    
    /**
     * Gets the "positions" element
     */
    public net.opengis.sensorML.x10.PositionsDocument.Positions getPositions()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.PositionsDocument.Positions target = null;
            target = (net.opengis.sensorML.x10.PositionsDocument.Positions)get_store().find_element_user(POSITIONS$8, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "positions" element
     */
    public boolean isSetPositions()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(POSITIONS$8) != 0;
        }
    }
    
    /**
     * Sets the "positions" element
     */
    public void setPositions(net.opengis.sensorML.x10.PositionsDocument.Positions positions)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.PositionsDocument.Positions target = null;
            target = (net.opengis.sensorML.x10.PositionsDocument.Positions)get_store().find_element_user(POSITIONS$8, 0);
            if (target == null)
            {
                target = (net.opengis.sensorML.x10.PositionsDocument.Positions)get_store().add_element_user(POSITIONS$8);
            }
            target.set(positions);
        }
    }
    
    /**
     * Appends and returns a new empty "positions" element
     */
    public net.opengis.sensorML.x10.PositionsDocument.Positions addNewPositions()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.PositionsDocument.Positions target = null;
            target = (net.opengis.sensorML.x10.PositionsDocument.Positions)get_store().add_element_user(POSITIONS$8);
            return target;
        }
    }
    
    /**
     * Unsets the "positions" element
     */
    public void unsetPositions()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(POSITIONS$8, 0);
        }
    }
    
    /**
     * Gets the "connections" element
     */
    public net.opengis.sensorML.x10.ConnectionsDocument.Connections getConnections()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.ConnectionsDocument.Connections target = null;
            target = (net.opengis.sensorML.x10.ConnectionsDocument.Connections)get_store().find_element_user(CONNECTIONS$10, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "connections" element
     */
    public boolean isSetConnections()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CONNECTIONS$10) != 0;
        }
    }
    
    /**
     * Sets the "connections" element
     */
    public void setConnections(net.opengis.sensorML.x10.ConnectionsDocument.Connections connections)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.ConnectionsDocument.Connections target = null;
            target = (net.opengis.sensorML.x10.ConnectionsDocument.Connections)get_store().find_element_user(CONNECTIONS$10, 0);
            if (target == null)
            {
                target = (net.opengis.sensorML.x10.ConnectionsDocument.Connections)get_store().add_element_user(CONNECTIONS$10);
            }
            target.set(connections);
        }
    }
    
    /**
     * Appends and returns a new empty "connections" element
     */
    public net.opengis.sensorML.x10.ConnectionsDocument.Connections addNewConnections()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.ConnectionsDocument.Connections target = null;
            target = (net.opengis.sensorML.x10.ConnectionsDocument.Connections)get_store().add_element_user(CONNECTIONS$10);
            return target;
        }
    }
    
    /**
     * Unsets the "connections" element
     */
    public void unsetConnections()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CONNECTIONS$10, 0);
        }
    }
    /**
     * An XML parameters(@http://www.opengis.net/sensorML/1.0).
     *
     * This is a complex type.
     */
    public static class ParametersImpl extends net.opengis.sensorML.x10.impl.ParametersPropertyTypeImpl implements net.opengis.sensorML.x10.ComponentArrayType.Parameters
    {
        private static final long serialVersionUID = 1L;
        
        public ParametersImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        
        /**
         * An XML ParameterList(@http://www.opengis.net/sensorML/1.0).
         *
         * This is a complex type.
         */
        public static class ParameterListImpl extends net.opengis.sensorML.x10.impl.AbstractListTypeImpl implements net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList
        {
            private static final long serialVersionUID = 1L;
            
            public ParameterListImpl(org.apache.xmlbeans.SchemaType sType)
            {
                super(sType);
            }
            
            private static final javax.xml.namespace.QName INDEX$0 = 
                new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "index");
            private static final javax.xml.namespace.QName PARAMETER$2 = 
                new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "parameter");
            
            
            /**
             * Gets array of all "index" elements
             */
            public net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index[] getIndexArray()
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    java.util.List targetList = new java.util.ArrayList();
                    get_store().find_all_element_users(INDEX$0, targetList);
                    net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index[] result = new net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index[targetList.size()];
                    targetList.toArray(result);
                    return result;
                }
            }
            
            /**
             * Gets ith "index" element
             */
            public net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index getIndexArray(int i)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index target = null;
                    target = (net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index)get_store().find_element_user(INDEX$0, i);
                    if (target == null)
                    {
                      throw new IndexOutOfBoundsException();
                    }
                    return target;
                }
            }
            
            /**
             * Returns number of "index" element
             */
            public int sizeOfIndexArray()
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    return get_store().count_elements(INDEX$0);
                }
            }
            
            /**
             * Sets array of all "index" element
             */
            public void setIndexArray(net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index[] indexArray)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    arraySetterHelper(indexArray, INDEX$0);
                }
            }
            
            /**
             * Sets ith "index" element
             */
            public void setIndexArray(int i, net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index index)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index target = null;
                    target = (net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index)get_store().find_element_user(INDEX$0, i);
                    if (target == null)
                    {
                      throw new IndexOutOfBoundsException();
                    }
                    target.set(index);
                }
            }
            
            /**
             * Inserts and returns a new empty value (as xml) as the ith "index" element
             */
            public net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index insertNewIndex(int i)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index target = null;
                    target = (net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index)get_store().insert_element_user(INDEX$0, i);
                    return target;
                }
            }
            
            /**
             * Appends and returns a new empty value (as xml) as the last "index" element
             */
            public net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index addNewIndex()
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index target = null;
                    target = (net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index)get_store().add_element_user(INDEX$0);
                    return target;
                }
            }
            
            /**
             * Removes the ith "index" element
             */
            public void removeIndex(int i)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    get_store().remove_element(INDEX$0, i);
                }
            }
            
            /**
             * Gets array of all "parameter" elements
             */
            public net.opengis.swe.x10.DataComponentPropertyType[] getParameterArray()
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    java.util.List targetList = new java.util.ArrayList();
                    get_store().find_all_element_users(PARAMETER$2, targetList);
                    net.opengis.swe.x10.DataComponentPropertyType[] result = new net.opengis.swe.x10.DataComponentPropertyType[targetList.size()];
                    targetList.toArray(result);
                    return result;
                }
            }
            
            /**
             * Gets ith "parameter" element
             */
            public net.opengis.swe.x10.DataComponentPropertyType getParameterArray(int i)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.swe.x10.DataComponentPropertyType target = null;
                    target = (net.opengis.swe.x10.DataComponentPropertyType)get_store().find_element_user(PARAMETER$2, i);
                    if (target == null)
                    {
                      throw new IndexOutOfBoundsException();
                    }
                    return target;
                }
            }
            
            /**
             * Returns number of "parameter" element
             */
            public int sizeOfParameterArray()
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    return get_store().count_elements(PARAMETER$2);
                }
            }
            
            /**
             * Sets array of all "parameter" element
             */
            public void setParameterArray(net.opengis.swe.x10.DataComponentPropertyType[] parameterArray)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    arraySetterHelper(parameterArray, PARAMETER$2);
                }
            }
            
            /**
             * Sets ith "parameter" element
             */
            public void setParameterArray(int i, net.opengis.swe.x10.DataComponentPropertyType parameter)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.swe.x10.DataComponentPropertyType target = null;
                    target = (net.opengis.swe.x10.DataComponentPropertyType)get_store().find_element_user(PARAMETER$2, i);
                    if (target == null)
                    {
                      throw new IndexOutOfBoundsException();
                    }
                    target.set(parameter);
                }
            }
            
            /**
             * Inserts and returns a new empty value (as xml) as the ith "parameter" element
             */
            public net.opengis.swe.x10.DataComponentPropertyType insertNewParameter(int i)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.swe.x10.DataComponentPropertyType target = null;
                    target = (net.opengis.swe.x10.DataComponentPropertyType)get_store().insert_element_user(PARAMETER$2, i);
                    return target;
                }
            }
            
            /**
             * Appends and returns a new empty value (as xml) as the last "parameter" element
             */
            public net.opengis.swe.x10.DataComponentPropertyType addNewParameter()
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    net.opengis.swe.x10.DataComponentPropertyType target = null;
                    target = (net.opengis.swe.x10.DataComponentPropertyType)get_store().add_element_user(PARAMETER$2);
                    return target;
                }
            }
            
            /**
             * Removes the ith "parameter" element
             */
            public void removeParameter(int i)
            {
                synchronized (monitor())
                {
                    check_orphaned();
                    get_store().remove_element(PARAMETER$2, i);
                }
            }
            /**
             * An XML index(@http://www.opengis.net/sensorML/1.0).
             *
             * This is a complex type.
             */
            public static class IndexImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorML.x10.ComponentArrayType.Parameters.ParameterList.Index
            {
                private static final long serialVersionUID = 1L;
                
                public IndexImpl(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 NAME$2 = 
                    new javax.xml.namespace.QName("", "name");
                
                
                /**
                 * 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;
                    }
                }
                
                /**
                 * 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;
                    }
                }
                
                /**
                 * 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$2);
                      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$2);
                      return target;
                    }
                }
                
                /**
                 * True if has "name" attribute
                 */
                public boolean isSetName()
                {
                    synchronized (monitor())
                    {
                      check_orphaned();
                      return get_store().find_attribute_user(NAME$2) != null;
                    }
                }
                
                /**
                 * 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$2);
                      if (target == null)
                      {
                        target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(NAME$2);
                      }
                      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$2);
                      if (target == null)
                      {
                        target = (org.apache.xmlbeans.XmlToken)get_store().add_attribute_user(NAME$2);
                      }
                      target.set(name);
                    }
                }
                
                /**
                 * Unsets the "name" attribute
                 */
                public void unsetName()
                {
                    synchronized (monitor())
                    {
                      check_orphaned();
                      get_store().remove_attribute(NAME$2);
                    }
                }
            }
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy