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

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

The newest version!
/*
 * An XML document type.
 * Localname: InterfaceDefinition
 * Namespace: http://www.opengis.net/sensorML/1.0
 * Java type: net.opengis.sensorML.x10.InterfaceDefinitionDocument
 *
 * Automatically generated - do not modify.
 */
package net.opengis.sensorML.x10.impl;
/**
 * A document containing one InterfaceDefinition(@http://www.opengis.net/sensorML/1.0) element.
 *
 * This is a complex type.
 */
public class InterfaceDefinitionDocumentImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorML.x10.InterfaceDefinitionDocument
{
    private static final long serialVersionUID = 1L;
    
    public InterfaceDefinitionDocumentImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName INTERFACEDEFINITION$0 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "InterfaceDefinition");
    
    
    /**
     * Gets the "InterfaceDefinition" element
     */
    public net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition getInterfaceDefinition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition target = null;
            target = (net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition)get_store().find_element_user(INTERFACEDEFINITION$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * Sets the "InterfaceDefinition" element
     */
    public void setInterfaceDefinition(net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition interfaceDefinition)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition target = null;
            target = (net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition)get_store().find_element_user(INTERFACEDEFINITION$0, 0);
            if (target == null)
            {
                target = (net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition)get_store().add_element_user(INTERFACEDEFINITION$0);
            }
            target.set(interfaceDefinition);
        }
    }
    
    /**
     * Appends and returns a new empty "InterfaceDefinition" element
     */
    public net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition addNewInterfaceDefinition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition target = null;
            target = (net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition)get_store().add_element_user(INTERFACEDEFINITION$0);
            return target;
        }
    }
    /**
     * An XML InterfaceDefinition(@http://www.opengis.net/sensorML/1.0).
     *
     * This is a complex type.
     */
    public static class InterfaceDefinitionImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorML.x10.InterfaceDefinitionDocument.InterfaceDefinition
    {
        private static final long serialVersionUID = 1L;
        
        public InterfaceDefinitionImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName SERVICELAYER$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "serviceLayer");
        private static final javax.xml.namespace.QName APPLICATIONLAYER$2 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "applicationLayer");
        private static final javax.xml.namespace.QName PRESENTATIONLAYER$4 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "presentationLayer");
        private static final javax.xml.namespace.QName SESSIONLAYER$6 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "sessionLayer");
        private static final javax.xml.namespace.QName TRANSPORTLAYER$8 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "transportLayer");
        private static final javax.xml.namespace.QName NETWORKLAYER$10 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "networkLayer");
        private static final javax.xml.namespace.QName DATALINKLAYER$12 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "dataLinkLayer");
        private static final javax.xml.namespace.QName PHYSICALLAYER$14 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "physicalLayer");
        private static final javax.xml.namespace.QName MECHANICALLAYER$16 = 
            new javax.xml.namespace.QName("http://www.opengis.net/sensorML/1.0", "mechanicalLayer");
        private static final javax.xml.namespace.QName ID$18 = 
            new javax.xml.namespace.QName("", "id");
        
        
        /**
         * Gets the "serviceLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType getServiceLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(SERVICELAYER$0, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "serviceLayer" element
         */
        public boolean isSetServiceLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(SERVICELAYER$0) != 0;
            }
        }
        
        /**
         * Sets the "serviceLayer" element
         */
        public void setServiceLayer(net.opengis.sensorML.x10.LayerPropertyType serviceLayer)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(SERVICELAYER$0, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(SERVICELAYER$0);
                }
                target.set(serviceLayer);
            }
        }
        
        /**
         * Appends and returns a new empty "serviceLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType addNewServiceLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(SERVICELAYER$0);
                return target;
            }
        }
        
        /**
         * Unsets the "serviceLayer" element
         */
        public void unsetServiceLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(SERVICELAYER$0, 0);
            }
        }
        
        /**
         * Gets the "applicationLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType getApplicationLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(APPLICATIONLAYER$2, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "applicationLayer" element
         */
        public boolean isSetApplicationLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(APPLICATIONLAYER$2) != 0;
            }
        }
        
        /**
         * Sets the "applicationLayer" element
         */
        public void setApplicationLayer(net.opengis.sensorML.x10.LayerPropertyType applicationLayer)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(APPLICATIONLAYER$2, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(APPLICATIONLAYER$2);
                }
                target.set(applicationLayer);
            }
        }
        
        /**
         * Appends and returns a new empty "applicationLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType addNewApplicationLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(APPLICATIONLAYER$2);
                return target;
            }
        }
        
        /**
         * Unsets the "applicationLayer" element
         */
        public void unsetApplicationLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(APPLICATIONLAYER$2, 0);
            }
        }
        
        /**
         * Gets the "presentationLayer" element
         */
        public net.opengis.sensorML.x10.PresentationLayerPropertyType getPresentationLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.PresentationLayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.PresentationLayerPropertyType)get_store().find_element_user(PRESENTATIONLAYER$4, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "presentationLayer" element
         */
        public boolean isSetPresentationLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(PRESENTATIONLAYER$4) != 0;
            }
        }
        
        /**
         * Sets the "presentationLayer" element
         */
        public void setPresentationLayer(net.opengis.sensorML.x10.PresentationLayerPropertyType presentationLayer)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.PresentationLayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.PresentationLayerPropertyType)get_store().find_element_user(PRESENTATIONLAYER$4, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorML.x10.PresentationLayerPropertyType)get_store().add_element_user(PRESENTATIONLAYER$4);
                }
                target.set(presentationLayer);
            }
        }
        
        /**
         * Appends and returns a new empty "presentationLayer" element
         */
        public net.opengis.sensorML.x10.PresentationLayerPropertyType addNewPresentationLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.PresentationLayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.PresentationLayerPropertyType)get_store().add_element_user(PRESENTATIONLAYER$4);
                return target;
            }
        }
        
        /**
         * Unsets the "presentationLayer" element
         */
        public void unsetPresentationLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(PRESENTATIONLAYER$4, 0);
            }
        }
        
        /**
         * Gets the "sessionLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType getSessionLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(SESSIONLAYER$6, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "sessionLayer" element
         */
        public boolean isSetSessionLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(SESSIONLAYER$6) != 0;
            }
        }
        
        /**
         * Sets the "sessionLayer" element
         */
        public void setSessionLayer(net.opengis.sensorML.x10.LayerPropertyType sessionLayer)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(SESSIONLAYER$6, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(SESSIONLAYER$6);
                }
                target.set(sessionLayer);
            }
        }
        
        /**
         * Appends and returns a new empty "sessionLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType addNewSessionLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(SESSIONLAYER$6);
                return target;
            }
        }
        
        /**
         * Unsets the "sessionLayer" element
         */
        public void unsetSessionLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(SESSIONLAYER$6, 0);
            }
        }
        
        /**
         * Gets the "transportLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType getTransportLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(TRANSPORTLAYER$8, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "transportLayer" element
         */
        public boolean isSetTransportLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(TRANSPORTLAYER$8) != 0;
            }
        }
        
        /**
         * Sets the "transportLayer" element
         */
        public void setTransportLayer(net.opengis.sensorML.x10.LayerPropertyType transportLayer)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(TRANSPORTLAYER$8, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(TRANSPORTLAYER$8);
                }
                target.set(transportLayer);
            }
        }
        
        /**
         * Appends and returns a new empty "transportLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType addNewTransportLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(TRANSPORTLAYER$8);
                return target;
            }
        }
        
        /**
         * Unsets the "transportLayer" element
         */
        public void unsetTransportLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(TRANSPORTLAYER$8, 0);
            }
        }
        
        /**
         * Gets the "networkLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType getNetworkLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(NETWORKLAYER$10, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "networkLayer" element
         */
        public boolean isSetNetworkLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(NETWORKLAYER$10) != 0;
            }
        }
        
        /**
         * Sets the "networkLayer" element
         */
        public void setNetworkLayer(net.opengis.sensorML.x10.LayerPropertyType networkLayer)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(NETWORKLAYER$10, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(NETWORKLAYER$10);
                }
                target.set(networkLayer);
            }
        }
        
        /**
         * Appends and returns a new empty "networkLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType addNewNetworkLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(NETWORKLAYER$10);
                return target;
            }
        }
        
        /**
         * Unsets the "networkLayer" element
         */
        public void unsetNetworkLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(NETWORKLAYER$10, 0);
            }
        }
        
        /**
         * Gets the "dataLinkLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType getDataLinkLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(DATALINKLAYER$12, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "dataLinkLayer" element
         */
        public boolean isSetDataLinkLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(DATALINKLAYER$12) != 0;
            }
        }
        
        /**
         * Sets the "dataLinkLayer" element
         */
        public void setDataLinkLayer(net.opengis.sensorML.x10.LayerPropertyType dataLinkLayer)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(DATALINKLAYER$12, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(DATALINKLAYER$12);
                }
                target.set(dataLinkLayer);
            }
        }
        
        /**
         * Appends and returns a new empty "dataLinkLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType addNewDataLinkLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(DATALINKLAYER$12);
                return target;
            }
        }
        
        /**
         * Unsets the "dataLinkLayer" element
         */
        public void unsetDataLinkLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(DATALINKLAYER$12, 0);
            }
        }
        
        /**
         * Gets the "physicalLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType getPhysicalLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(PHYSICALLAYER$14, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "physicalLayer" element
         */
        public boolean isSetPhysicalLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(PHYSICALLAYER$14) != 0;
            }
        }
        
        /**
         * Sets the "physicalLayer" element
         */
        public void setPhysicalLayer(net.opengis.sensorML.x10.LayerPropertyType physicalLayer)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(PHYSICALLAYER$14, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(PHYSICALLAYER$14);
                }
                target.set(physicalLayer);
            }
        }
        
        /**
         * Appends and returns a new empty "physicalLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType addNewPhysicalLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(PHYSICALLAYER$14);
                return target;
            }
        }
        
        /**
         * Unsets the "physicalLayer" element
         */
        public void unsetPhysicalLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(PHYSICALLAYER$14, 0);
            }
        }
        
        /**
         * Gets the "mechanicalLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType getMechanicalLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(MECHANICALLAYER$16, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "mechanicalLayer" element
         */
        public boolean isSetMechanicalLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(MECHANICALLAYER$16) != 0;
            }
        }
        
        /**
         * Sets the "mechanicalLayer" element
         */
        public void setMechanicalLayer(net.opengis.sensorML.x10.LayerPropertyType mechanicalLayer)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().find_element_user(MECHANICALLAYER$16, 0);
                if (target == null)
                {
                    target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(MECHANICALLAYER$16);
                }
                target.set(mechanicalLayer);
            }
        }
        
        /**
         * Appends and returns a new empty "mechanicalLayer" element
         */
        public net.opengis.sensorML.x10.LayerPropertyType addNewMechanicalLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.sensorML.x10.LayerPropertyType target = null;
                target = (net.opengis.sensorML.x10.LayerPropertyType)get_store().add_element_user(MECHANICALLAYER$16);
                return target;
            }
        }
        
        /**
         * Unsets the "mechanicalLayer" element
         */
        public void unsetMechanicalLayer()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(MECHANICALLAYER$16, 0);
            }
        }
        
        /**
         * Gets the "id" attribute
         */
        public java.lang.String getId()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ID$18);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "id" attribute
         */
        public org.apache.xmlbeans.XmlID xgetId()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlID target = null;
                target = (org.apache.xmlbeans.XmlID)get_store().find_attribute_user(ID$18);
                return target;
            }
        }
        
        /**
         * True if has "id" attribute
         */
        public boolean isSetId()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ID$18) != null;
            }
        }
        
        /**
         * Sets the "id" attribute
         */
        public void setId(java.lang.String id)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ID$18);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ID$18);
                }
                target.setStringValue(id);
            }
        }
        
        /**
         * Sets (as xml) the "id" attribute
         */
        public void xsetId(org.apache.xmlbeans.XmlID id)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlID target = null;
                target = (org.apache.xmlbeans.XmlID)get_store().find_attribute_user(ID$18);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlID)get_store().add_attribute_user(ID$18);
                }
                target.set(id);
            }
        }
        
        /**
         * Unsets the "id" attribute
         */
        public void unsetId()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ID$18);
            }
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy