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

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

There is a newer version: 2.7.0
Show newest version
/*
 * XML Type:  DescribedObjectType
 * Namespace: http://www.opengis.net/sensorml/2.0
 * Java type: net.opengis.sensorml.x20.DescribedObjectType
 *
 * Automatically generated - do not modify.
 */
package net.opengis.sensorml.x20.impl;
/**
 * An XML DescribedObjectType(@http://www.opengis.net/sensorml/2.0).
 *
 * This is a complex type.
 */
public class DescribedObjectTypeImpl extends net.opengis.gml.x32.impl.AbstractFeatureTypeImpl implements net.opengis.sensorml.x20.DescribedObjectType
{
    private static final long serialVersionUID = 1L;
    
    public DescribedObjectTypeImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName EXTENSION$0 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "extension");
    private static final javax.xml.namespace.QName KEYWORDS$2 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "keywords");
    private static final javax.xml.namespace.QName IDENTIFICATION$4 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "identification");
    private static final javax.xml.namespace.QName CLASSIFICATION$6 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "classification");
    private static final javax.xml.namespace.QName VALIDTIME$8 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "validTime");
    private static final javax.xml.namespace.QName SECURITYCONSTRAINTS$10 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "securityConstraints");
    private static final javax.xml.namespace.QName LEGALCONSTRAINTS$12 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "legalConstraints");
    private static final javax.xml.namespace.QName CHARACTERISTICS$14 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "characteristics");
    private static final javax.xml.namespace.QName CAPABILITIES$16 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "capabilities");
    private static final javax.xml.namespace.QName CONTACTS$18 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "contacts");
    private static final javax.xml.namespace.QName DOCUMENTATION$20 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "documentation");
    private static final javax.xml.namespace.QName HISTORY$22 = 
        new javax.xml.namespace.QName("http://www.opengis.net/sensorml/2.0", "history");
    private static final javax.xml.namespace.QName LANG$24 = 
        new javax.xml.namespace.QName("http://www.w3.org/XML/1998/namespace", "lang");
    
    
    /**
     * Gets array of all "extension" elements
     */
    public org.apache.xmlbeans.XmlObject[] getExtensionArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(EXTENSION$0, targetList);
            org.apache.xmlbeans.XmlObject[] result = new org.apache.xmlbeans.XmlObject[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "extension" element
     */
    public org.apache.xmlbeans.XmlObject getExtensionArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlObject target = null;
            target = (org.apache.xmlbeans.XmlObject)get_store().find_element_user(EXTENSION$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "extension" element
     */
    public int sizeOfExtensionArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EXTENSION$0);
        }
    }
    
    /**
     * Sets array of all "extension" element
     */
    public void setExtensionArray(org.apache.xmlbeans.XmlObject[] extensionArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(extensionArray, EXTENSION$0);
        }
    }
    
    /**
     * Sets ith "extension" element
     */
    public void setExtensionArray(int i, org.apache.xmlbeans.XmlObject extension)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlObject target = null;
            target = (org.apache.xmlbeans.XmlObject)get_store().find_element_user(EXTENSION$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(extension);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "extension" element
     */
    public org.apache.xmlbeans.XmlObject insertNewExtension(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlObject target = null;
            target = (org.apache.xmlbeans.XmlObject)get_store().insert_element_user(EXTENSION$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "extension" element
     */
    public org.apache.xmlbeans.XmlObject addNewExtension()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlObject target = null;
            target = (org.apache.xmlbeans.XmlObject)get_store().add_element_user(EXTENSION$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "extension" element
     */
    public void removeExtension(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EXTENSION$0, i);
        }
    }
    
    /**
     * Gets array of all "keywords" elements
     */
    public net.opengis.sensorml.x20.KeywordListPropertyType[] getKeywordsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(KEYWORDS$2, targetList);
            net.opengis.sensorml.x20.KeywordListPropertyType[] result = new net.opengis.sensorml.x20.KeywordListPropertyType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "keywords" element
     */
    public net.opengis.sensorml.x20.KeywordListPropertyType getKeywordsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.KeywordListPropertyType target = null;
            target = (net.opengis.sensorml.x20.KeywordListPropertyType)get_store().find_element_user(KEYWORDS$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "keywords" element
     */
    public int sizeOfKeywordsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(KEYWORDS$2);
        }
    }
    
    /**
     * Sets array of all "keywords" element
     */
    public void setKeywordsArray(net.opengis.sensorml.x20.KeywordListPropertyType[] keywordsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(keywordsArray, KEYWORDS$2);
        }
    }
    
    /**
     * Sets ith "keywords" element
     */
    public void setKeywordsArray(int i, net.opengis.sensorml.x20.KeywordListPropertyType keywords)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.KeywordListPropertyType target = null;
            target = (net.opengis.sensorml.x20.KeywordListPropertyType)get_store().find_element_user(KEYWORDS$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(keywords);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "keywords" element
     */
    public net.opengis.sensorml.x20.KeywordListPropertyType insertNewKeywords(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.KeywordListPropertyType target = null;
            target = (net.opengis.sensorml.x20.KeywordListPropertyType)get_store().insert_element_user(KEYWORDS$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "keywords" element
     */
    public net.opengis.sensorml.x20.KeywordListPropertyType addNewKeywords()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.KeywordListPropertyType target = null;
            target = (net.opengis.sensorml.x20.KeywordListPropertyType)get_store().add_element_user(KEYWORDS$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "keywords" element
     */
    public void removeKeywords(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(KEYWORDS$2, i);
        }
    }
    
    /**
     * Gets array of all "identification" elements
     */
    public net.opengis.sensorml.x20.IdentifierListPropertyType[] getIdentificationArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(IDENTIFICATION$4, targetList);
            net.opengis.sensorml.x20.IdentifierListPropertyType[] result = new net.opengis.sensorml.x20.IdentifierListPropertyType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "identification" element
     */
    public net.opengis.sensorml.x20.IdentifierListPropertyType getIdentificationArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.IdentifierListPropertyType target = null;
            target = (net.opengis.sensorml.x20.IdentifierListPropertyType)get_store().find_element_user(IDENTIFICATION$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "identification" element
     */
    public int sizeOfIdentificationArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(IDENTIFICATION$4);
        }
    }
    
    /**
     * Sets array of all "identification" element
     */
    public void setIdentificationArray(net.opengis.sensorml.x20.IdentifierListPropertyType[] identificationArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(identificationArray, IDENTIFICATION$4);
        }
    }
    
    /**
     * Sets ith "identification" element
     */
    public void setIdentificationArray(int i, net.opengis.sensorml.x20.IdentifierListPropertyType identification)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.IdentifierListPropertyType target = null;
            target = (net.opengis.sensorml.x20.IdentifierListPropertyType)get_store().find_element_user(IDENTIFICATION$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(identification);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "identification" element
     */
    public net.opengis.sensorml.x20.IdentifierListPropertyType insertNewIdentification(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.IdentifierListPropertyType target = null;
            target = (net.opengis.sensorml.x20.IdentifierListPropertyType)get_store().insert_element_user(IDENTIFICATION$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "identification" element
     */
    public net.opengis.sensorml.x20.IdentifierListPropertyType addNewIdentification()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.IdentifierListPropertyType target = null;
            target = (net.opengis.sensorml.x20.IdentifierListPropertyType)get_store().add_element_user(IDENTIFICATION$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "identification" element
     */
    public void removeIdentification(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(IDENTIFICATION$4, i);
        }
    }
    
    /**
     * Gets array of all "classification" elements
     */
    public net.opengis.sensorml.x20.ClassifierListPropertyType[] getClassificationArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CLASSIFICATION$6, targetList);
            net.opengis.sensorml.x20.ClassifierListPropertyType[] result = new net.opengis.sensorml.x20.ClassifierListPropertyType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "classification" element
     */
    public net.opengis.sensorml.x20.ClassifierListPropertyType getClassificationArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.ClassifierListPropertyType target = null;
            target = (net.opengis.sensorml.x20.ClassifierListPropertyType)get_store().find_element_user(CLASSIFICATION$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "classification" element
     */
    public int sizeOfClassificationArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CLASSIFICATION$6);
        }
    }
    
    /**
     * Sets array of all "classification" element
     */
    public void setClassificationArray(net.opengis.sensorml.x20.ClassifierListPropertyType[] classificationArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(classificationArray, CLASSIFICATION$6);
        }
    }
    
    /**
     * Sets ith "classification" element
     */
    public void setClassificationArray(int i, net.opengis.sensorml.x20.ClassifierListPropertyType classification)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.ClassifierListPropertyType target = null;
            target = (net.opengis.sensorml.x20.ClassifierListPropertyType)get_store().find_element_user(CLASSIFICATION$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(classification);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "classification" element
     */
    public net.opengis.sensorml.x20.ClassifierListPropertyType insertNewClassification(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.ClassifierListPropertyType target = null;
            target = (net.opengis.sensorml.x20.ClassifierListPropertyType)get_store().insert_element_user(CLASSIFICATION$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "classification" element
     */
    public net.opengis.sensorml.x20.ClassifierListPropertyType addNewClassification()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.ClassifierListPropertyType target = null;
            target = (net.opengis.sensorml.x20.ClassifierListPropertyType)get_store().add_element_user(CLASSIFICATION$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "classification" element
     */
    public void removeClassification(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CLASSIFICATION$6, i);
        }
    }
    
    /**
     * Gets array of all "validTime" elements
     */
    public net.opengis.sensorml.x20.DescribedObjectType.ValidTime[] getValidTimeArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(VALIDTIME$8, targetList);
            net.opengis.sensorml.x20.DescribedObjectType.ValidTime[] result = new net.opengis.sensorml.x20.DescribedObjectType.ValidTime[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "validTime" element
     */
    public net.opengis.sensorml.x20.DescribedObjectType.ValidTime getValidTimeArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.ValidTime target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.ValidTime)get_store().find_element_user(VALIDTIME$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "validTime" element
     */
    public int sizeOfValidTimeArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(VALIDTIME$8);
        }
    }
    
    /**
     * Sets array of all "validTime" element
     */
    public void setValidTimeArray(net.opengis.sensorml.x20.DescribedObjectType.ValidTime[] validTimeArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(validTimeArray, VALIDTIME$8);
        }
    }
    
    /**
     * Sets ith "validTime" element
     */
    public void setValidTimeArray(int i, net.opengis.sensorml.x20.DescribedObjectType.ValidTime validTime)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.ValidTime target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.ValidTime)get_store().find_element_user(VALIDTIME$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(validTime);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "validTime" element
     */
    public net.opengis.sensorml.x20.DescribedObjectType.ValidTime insertNewValidTime(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.ValidTime target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.ValidTime)get_store().insert_element_user(VALIDTIME$8, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "validTime" element
     */
    public net.opengis.sensorml.x20.DescribedObjectType.ValidTime addNewValidTime()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.ValidTime target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.ValidTime)get_store().add_element_user(VALIDTIME$8);
            return target;
        }
    }
    
    /**
     * Removes the ith "validTime" element
     */
    public void removeValidTime(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(VALIDTIME$8, i);
        }
    }
    
    /**
     * Gets array of all "securityConstraints" elements
     */
    public org.apache.xmlbeans.XmlObject[] getSecurityConstraintsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SECURITYCONSTRAINTS$10, targetList);
            org.apache.xmlbeans.XmlObject[] result = new org.apache.xmlbeans.XmlObject[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "securityConstraints" element
     */
    public org.apache.xmlbeans.XmlObject getSecurityConstraintsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlObject target = null;
            target = (org.apache.xmlbeans.XmlObject)get_store().find_element_user(SECURITYCONSTRAINTS$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "securityConstraints" element
     */
    public int sizeOfSecurityConstraintsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SECURITYCONSTRAINTS$10);
        }
    }
    
    /**
     * Sets array of all "securityConstraints" element
     */
    public void setSecurityConstraintsArray(org.apache.xmlbeans.XmlObject[] securityConstraintsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(securityConstraintsArray, SECURITYCONSTRAINTS$10);
        }
    }
    
    /**
     * Sets ith "securityConstraints" element
     */
    public void setSecurityConstraintsArray(int i, org.apache.xmlbeans.XmlObject securityConstraints)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlObject target = null;
            target = (org.apache.xmlbeans.XmlObject)get_store().find_element_user(SECURITYCONSTRAINTS$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(securityConstraints);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "securityConstraints" element
     */
    public org.apache.xmlbeans.XmlObject insertNewSecurityConstraints(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlObject target = null;
            target = (org.apache.xmlbeans.XmlObject)get_store().insert_element_user(SECURITYCONSTRAINTS$10, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "securityConstraints" element
     */
    public org.apache.xmlbeans.XmlObject addNewSecurityConstraints()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlObject target = null;
            target = (org.apache.xmlbeans.XmlObject)get_store().add_element_user(SECURITYCONSTRAINTS$10);
            return target;
        }
    }
    
    /**
     * Removes the ith "securityConstraints" element
     */
    public void removeSecurityConstraints(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SECURITYCONSTRAINTS$10, i);
        }
    }
    
    /**
     * Gets array of all "legalConstraints" elements
     */
    public org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType[] getLegalConstraintsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(LEGALCONSTRAINTS$12, targetList);
            org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType[] result = new org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "legalConstraints" element
     */
    public org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType getLegalConstraintsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType target = null;
            target = (org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType)get_store().find_element_user(LEGALCONSTRAINTS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "legalConstraints" element
     */
    public int sizeOfLegalConstraintsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LEGALCONSTRAINTS$12);
        }
    }
    
    /**
     * Sets array of all "legalConstraints" element
     */
    public void setLegalConstraintsArray(org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType[] legalConstraintsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(legalConstraintsArray, LEGALCONSTRAINTS$12);
        }
    }
    
    /**
     * Sets ith "legalConstraints" element
     */
    public void setLegalConstraintsArray(int i, org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType legalConstraints)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType target = null;
            target = (org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType)get_store().find_element_user(LEGALCONSTRAINTS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(legalConstraints);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "legalConstraints" element
     */
    public org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType insertNewLegalConstraints(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType target = null;
            target = (org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType)get_store().insert_element_user(LEGALCONSTRAINTS$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "legalConstraints" element
     */
    public org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType addNewLegalConstraints()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType target = null;
            target = (org.isotc211.x2005.gmd.MDLegalConstraintsPropertyType)get_store().add_element_user(LEGALCONSTRAINTS$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "legalConstraints" element
     */
    public void removeLegalConstraints(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LEGALCONSTRAINTS$12, i);
        }
    }
    
    /**
     * Gets array of all "characteristics" elements
     */
    public net.opengis.sensorml.x20.DescribedObjectType.Characteristics[] getCharacteristicsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CHARACTERISTICS$14, targetList);
            net.opengis.sensorml.x20.DescribedObjectType.Characteristics[] result = new net.opengis.sensorml.x20.DescribedObjectType.Characteristics[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "characteristics" element
     */
    public net.opengis.sensorml.x20.DescribedObjectType.Characteristics getCharacteristicsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.Characteristics target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.Characteristics)get_store().find_element_user(CHARACTERISTICS$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "characteristics" element
     */
    public int sizeOfCharacteristicsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CHARACTERISTICS$14);
        }
    }
    
    /**
     * Sets array of all "characteristics" element
     */
    public void setCharacteristicsArray(net.opengis.sensorml.x20.DescribedObjectType.Characteristics[] characteristicsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(characteristicsArray, CHARACTERISTICS$14);
        }
    }
    
    /**
     * Sets ith "characteristics" element
     */
    public void setCharacteristicsArray(int i, net.opengis.sensorml.x20.DescribedObjectType.Characteristics characteristics)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.Characteristics target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.Characteristics)get_store().find_element_user(CHARACTERISTICS$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(characteristics);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "characteristics" element
     */
    public net.opengis.sensorml.x20.DescribedObjectType.Characteristics insertNewCharacteristics(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.Characteristics target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.Characteristics)get_store().insert_element_user(CHARACTERISTICS$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "characteristics" element
     */
    public net.opengis.sensorml.x20.DescribedObjectType.Characteristics addNewCharacteristics()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.Characteristics target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.Characteristics)get_store().add_element_user(CHARACTERISTICS$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "characteristics" element
     */
    public void removeCharacteristics(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CHARACTERISTICS$14, i);
        }
    }
    
    /**
     * Gets array of all "capabilities" elements
     */
    public net.opengis.sensorml.x20.DescribedObjectType.Capabilities[] getCapabilitiesArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CAPABILITIES$16, targetList);
            net.opengis.sensorml.x20.DescribedObjectType.Capabilities[] result = new net.opengis.sensorml.x20.DescribedObjectType.Capabilities[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "capabilities" element
     */
    public net.opengis.sensorml.x20.DescribedObjectType.Capabilities getCapabilitiesArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.Capabilities target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.Capabilities)get_store().find_element_user(CAPABILITIES$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "capabilities" element
     */
    public int sizeOfCapabilitiesArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CAPABILITIES$16);
        }
    }
    
    /**
     * Sets array of all "capabilities" element
     */
    public void setCapabilitiesArray(net.opengis.sensorml.x20.DescribedObjectType.Capabilities[] capabilitiesArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(capabilitiesArray, CAPABILITIES$16);
        }
    }
    
    /**
     * Sets ith "capabilities" element
     */
    public void setCapabilitiesArray(int i, net.opengis.sensorml.x20.DescribedObjectType.Capabilities capabilities)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.Capabilities target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.Capabilities)get_store().find_element_user(CAPABILITIES$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(capabilities);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "capabilities" element
     */
    public net.opengis.sensorml.x20.DescribedObjectType.Capabilities insertNewCapabilities(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.Capabilities target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.Capabilities)get_store().insert_element_user(CAPABILITIES$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "capabilities" element
     */
    public net.opengis.sensorml.x20.DescribedObjectType.Capabilities addNewCapabilities()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DescribedObjectType.Capabilities target = null;
            target = (net.opengis.sensorml.x20.DescribedObjectType.Capabilities)get_store().add_element_user(CAPABILITIES$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "capabilities" element
     */
    public void removeCapabilities(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CAPABILITIES$16, i);
        }
    }
    
    /**
     * Gets array of all "contacts" elements
     */
    public net.opengis.sensorml.x20.ContactListPropertyType[] getContactsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CONTACTS$18, targetList);
            net.opengis.sensorml.x20.ContactListPropertyType[] result = new net.opengis.sensorml.x20.ContactListPropertyType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "contacts" element
     */
    public net.opengis.sensorml.x20.ContactListPropertyType getContactsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.ContactListPropertyType target = null;
            target = (net.opengis.sensorml.x20.ContactListPropertyType)get_store().find_element_user(CONTACTS$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "contacts" element
     */
    public int sizeOfContactsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CONTACTS$18);
        }
    }
    
    /**
     * Sets array of all "contacts" element
     */
    public void setContactsArray(net.opengis.sensorml.x20.ContactListPropertyType[] contactsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(contactsArray, CONTACTS$18);
        }
    }
    
    /**
     * Sets ith "contacts" element
     */
    public void setContactsArray(int i, net.opengis.sensorml.x20.ContactListPropertyType contacts)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.ContactListPropertyType target = null;
            target = (net.opengis.sensorml.x20.ContactListPropertyType)get_store().find_element_user(CONTACTS$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(contacts);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "contacts" element
     */
    public net.opengis.sensorml.x20.ContactListPropertyType insertNewContacts(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.ContactListPropertyType target = null;
            target = (net.opengis.sensorml.x20.ContactListPropertyType)get_store().insert_element_user(CONTACTS$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "contacts" element
     */
    public net.opengis.sensorml.x20.ContactListPropertyType addNewContacts()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.ContactListPropertyType target = null;
            target = (net.opengis.sensorml.x20.ContactListPropertyType)get_store().add_element_user(CONTACTS$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "contacts" element
     */
    public void removeContacts(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CONTACTS$18, i);
        }
    }
    
    /**
     * Gets array of all "documentation" elements
     */
    public net.opengis.sensorml.x20.DocumentListPropertyType[] getDocumentationArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(DOCUMENTATION$20, targetList);
            net.opengis.sensorml.x20.DocumentListPropertyType[] result = new net.opengis.sensorml.x20.DocumentListPropertyType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "documentation" element
     */
    public net.opengis.sensorml.x20.DocumentListPropertyType getDocumentationArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DocumentListPropertyType target = null;
            target = (net.opengis.sensorml.x20.DocumentListPropertyType)get_store().find_element_user(DOCUMENTATION$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "documentation" element
     */
    public int sizeOfDocumentationArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DOCUMENTATION$20);
        }
    }
    
    /**
     * Sets array of all "documentation" element
     */
    public void setDocumentationArray(net.opengis.sensorml.x20.DocumentListPropertyType[] documentationArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(documentationArray, DOCUMENTATION$20);
        }
    }
    
    /**
     * Sets ith "documentation" element
     */
    public void setDocumentationArray(int i, net.opengis.sensorml.x20.DocumentListPropertyType documentation)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DocumentListPropertyType target = null;
            target = (net.opengis.sensorml.x20.DocumentListPropertyType)get_store().find_element_user(DOCUMENTATION$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(documentation);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "documentation" element
     */
    public net.opengis.sensorml.x20.DocumentListPropertyType insertNewDocumentation(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DocumentListPropertyType target = null;
            target = (net.opengis.sensorml.x20.DocumentListPropertyType)get_store().insert_element_user(DOCUMENTATION$20, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "documentation" element
     */
    public net.opengis.sensorml.x20.DocumentListPropertyType addNewDocumentation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.DocumentListPropertyType target = null;
            target = (net.opengis.sensorml.x20.DocumentListPropertyType)get_store().add_element_user(DOCUMENTATION$20);
            return target;
        }
    }
    
    /**
     * Removes the ith "documentation" element
     */
    public void removeDocumentation(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DOCUMENTATION$20, i);
        }
    }
    
    /**
     * Gets array of all "history" elements
     */
    public net.opengis.sensorml.x20.EventListPropertyType[] getHistoryArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(HISTORY$22, targetList);
            net.opengis.sensorml.x20.EventListPropertyType[] result = new net.opengis.sensorml.x20.EventListPropertyType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "history" element
     */
    public net.opengis.sensorml.x20.EventListPropertyType getHistoryArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.EventListPropertyType target = null;
            target = (net.opengis.sensorml.x20.EventListPropertyType)get_store().find_element_user(HISTORY$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "history" element
     */
    public int sizeOfHistoryArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(HISTORY$22);
        }
    }
    
    /**
     * Sets array of all "history" element
     */
    public void setHistoryArray(net.opengis.sensorml.x20.EventListPropertyType[] historyArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(historyArray, HISTORY$22);
        }
    }
    
    /**
     * Sets ith "history" element
     */
    public void setHistoryArray(int i, net.opengis.sensorml.x20.EventListPropertyType history)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.EventListPropertyType target = null;
            target = (net.opengis.sensorml.x20.EventListPropertyType)get_store().find_element_user(HISTORY$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(history);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "history" element
     */
    public net.opengis.sensorml.x20.EventListPropertyType insertNewHistory(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.EventListPropertyType target = null;
            target = (net.opengis.sensorml.x20.EventListPropertyType)get_store().insert_element_user(HISTORY$22, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "history" element
     */
    public net.opengis.sensorml.x20.EventListPropertyType addNewHistory()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.opengis.sensorml.x20.EventListPropertyType target = null;
            target = (net.opengis.sensorml.x20.EventListPropertyType)get_store().add_element_user(HISTORY$22);
            return target;
        }
    }
    
    /**
     * Removes the ith "history" element
     */
    public void removeHistory(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(HISTORY$22, i);
        }
    }
    
    /**
     * Gets the "lang" attribute
     */
    public java.lang.String getLang()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LANG$24);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "lang" attribute
     */
    public org.apache.xmlbeans.XmlLanguage xgetLang()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlLanguage target = null;
            target = (org.apache.xmlbeans.XmlLanguage)get_store().find_attribute_user(LANG$24);
            return target;
        }
    }
    
    /**
     * True if has "lang" attribute
     */
    public boolean isSetLang()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(LANG$24) != null;
        }
    }
    
    /**
     * Sets the "lang" attribute
     */
    public void setLang(java.lang.String lang)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LANG$24);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(LANG$24);
            }
            target.setStringValue(lang);
        }
    }
    
    /**
     * Sets (as xml) the "lang" attribute
     */
    public void xsetLang(org.apache.xmlbeans.XmlLanguage lang)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlLanguage target = null;
            target = (org.apache.xmlbeans.XmlLanguage)get_store().find_attribute_user(LANG$24);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlLanguage)get_store().add_attribute_user(LANG$24);
            }
            target.set(lang);
        }
    }
    
    /**
     * Unsets the "lang" attribute
     */
    public void unsetLang()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(LANG$24);
        }
    }
    /**
     * An XML validTime(@http://www.opengis.net/sensorml/2.0).
     *
     * This is a complex type.
     */
    public static class ValidTimeImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.opengis.sensorml.x20.DescribedObjectType.ValidTime
    {
        private static final long serialVersionUID = 1L;
        
        public ValidTimeImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName TIMEPERIOD$0 = 
            new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "TimePeriod");
        private static final javax.xml.namespace.QName TIMEINSTANT$2 = 
            new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "TimeInstant");
        
        
        /**
         * Gets the "TimePeriod" element
         */
        public net.opengis.gml.x32.TimePeriodType getTimePeriod()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.gml.x32.TimePeriodType target = null;
                target = (net.opengis.gml.x32.TimePeriodType)get_store().find_element_user(TIMEPERIOD$0, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TimePeriod" element
         */
        public boolean isSetTimePeriod()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(TIMEPERIOD$0) != 0;
            }
        }
        
        /**
         * Sets the "TimePeriod" element
         */
        public void setTimePeriod(net.opengis.gml.x32.TimePeriodType timePeriod)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.gml.x32.TimePeriodType target = null;
                target = (net.opengis.gml.x32.TimePeriodType)get_store().find_element_user(TIMEPERIOD$0, 0);
                if (target == null)
                {
                    target = (net.opengis.gml.x32.TimePeriodType)get_store().add_element_user(TIMEPERIOD$0);
                }
                target.set(timePeriod);
            }
        }
        
        /**
         * Appends and returns a new empty "TimePeriod" element
         */
        public net.opengis.gml.x32.TimePeriodType addNewTimePeriod()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.gml.x32.TimePeriodType target = null;
                target = (net.opengis.gml.x32.TimePeriodType)get_store().add_element_user(TIMEPERIOD$0);
                return target;
            }
        }
        
        /**
         * Unsets the "TimePeriod" element
         */
        public void unsetTimePeriod()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(TIMEPERIOD$0, 0);
            }
        }
        
        /**
         * Gets the "TimeInstant" element
         */
        public net.opengis.gml.x32.TimeInstantType getTimeInstant()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.gml.x32.TimeInstantType target = null;
                target = (net.opengis.gml.x32.TimeInstantType)get_store().find_element_user(TIMEINSTANT$2, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TimeInstant" element
         */
        public boolean isSetTimeInstant()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(TIMEINSTANT$2) != 0;
            }
        }
        
        /**
         * Sets the "TimeInstant" element
         */
        public void setTimeInstant(net.opengis.gml.x32.TimeInstantType timeInstant)
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.gml.x32.TimeInstantType target = null;
                target = (net.opengis.gml.x32.TimeInstantType)get_store().find_element_user(TIMEINSTANT$2, 0);
                if (target == null)
                {
                    target = (net.opengis.gml.x32.TimeInstantType)get_store().add_element_user(TIMEINSTANT$2);
                }
                target.set(timeInstant);
            }
        }
        
        /**
         * Appends and returns a new empty "TimeInstant" element
         */
        public net.opengis.gml.x32.TimeInstantType addNewTimeInstant()
        {
            synchronized (monitor())
            {
                check_orphaned();
                net.opengis.gml.x32.TimeInstantType target = null;
                target = (net.opengis.gml.x32.TimeInstantType)get_store().add_element_user(TIMEINSTANT$2);
                return target;
            }
        }
        
        /**
         * Unsets the "TimeInstant" element
         */
        public void unsetTimeInstant()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(TIMEINSTANT$2, 0);
            }
        }
    }
    /**
     * An XML characteristics(@http://www.opengis.net/sensorml/2.0).
     *
     * This is a complex type.
     */
    public static class CharacteristicsImpl extends net.opengis.sensorml.x20.impl.CharacteristicListPropertyTypeImpl implements net.opengis.sensorml.x20.DescribedObjectType.Characteristics
    {
        private static final long serialVersionUID = 1L;
        
        public CharacteristicsImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName NAME$0 = 
            new javax.xml.namespace.QName("", "name");
        
        
        /**
         * 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$0);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "name" attribute
         */
        public org.apache.xmlbeans.XmlNCName xgetName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlNCName target = null;
                target = (org.apache.xmlbeans.XmlNCName)get_store().find_attribute_user(NAME$0);
                return target;
            }
        }
        
        /**
         * Sets the "name" attribute
         */
        public void setName(java.lang.String name)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(NAME$0);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(NAME$0);
                }
                target.setStringValue(name);
            }
        }
        
        /**
         * Sets (as xml) the "name" attribute
         */
        public void xsetName(org.apache.xmlbeans.XmlNCName name)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlNCName target = null;
                target = (org.apache.xmlbeans.XmlNCName)get_store().find_attribute_user(NAME$0);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlNCName)get_store().add_attribute_user(NAME$0);
                }
                target.set(name);
            }
        }
    }
    /**
     * An XML capabilities(@http://www.opengis.net/sensorml/2.0).
     *
     * This is a complex type.
     */
    public static class CapabilitiesImpl extends net.opengis.sensorml.x20.impl.CapabilityListPropertyTypeImpl implements net.opengis.sensorml.x20.DescribedObjectType.Capabilities
    {
        private static final long serialVersionUID = 1L;
        
        public CapabilitiesImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName NAME$0 = 
            new javax.xml.namespace.QName("", "name");
        
        
        /**
         * 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$0);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "name" attribute
         */
        public org.apache.xmlbeans.XmlNCName xgetName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlNCName target = null;
                target = (org.apache.xmlbeans.XmlNCName)get_store().find_attribute_user(NAME$0);
                return target;
            }
        }
        
        /**
         * Sets the "name" attribute
         */
        public void setName(java.lang.String name)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(NAME$0);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(NAME$0);
                }
                target.setStringValue(name);
            }
        }
        
        /**
         * Sets (as xml) the "name" attribute
         */
        public void xsetName(org.apache.xmlbeans.XmlNCName name)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlNCName target = null;
                target = (org.apache.xmlbeans.XmlNCName)get_store().find_attribute_user(NAME$0);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlNCName)get_store().add_attribute_user(NAME$0);
                }
                target.set(name);
            }
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy