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

io.github.isotes.vs.model.impl.XSDDocumentImpl Maven / Gradle / Ivy

Go to download

Generated XMLBeans Java classes for the XML schema of MSBuild project files

The newest version!
/*
 * An XML document type.
 * Localname: XSD
 * Namespace: http://schemas.microsoft.com/developer/msbuild/2003
 * Java type: io.github.isotes.vs.model.XSDDocument
 *
 * Automatically generated - do not modify.
 */
package io.github.isotes.vs.model.impl;
/**
 * A document containing one XSD(@http://schemas.microsoft.com/developer/msbuild/2003) element.
 *
 * This is a complex type.
 */
public class XSDDocumentImpl extends io.github.isotes.vs.model.impl.TaskDocumentImpl implements io.github.isotes.vs.model.XSDDocument
{
    private static final long serialVersionUID = 1L;
    
    public XSDDocumentImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName XSD$0 = 
        new javax.xml.namespace.QName("http://schemas.microsoft.com/developer/msbuild/2003", "XSD");
    
    
    /**
     * Gets the "XSD" element
     */
    public io.github.isotes.vs.model.XSDDocument.XSD getXSD()
    {
        synchronized (monitor())
        {
            check_orphaned();
            io.github.isotes.vs.model.XSDDocument.XSD target = null;
            target = (io.github.isotes.vs.model.XSDDocument.XSD)get_store().find_element_user(XSD$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * Sets the "XSD" element
     */
    public void setXSD(io.github.isotes.vs.model.XSDDocument.XSD xsd)
    {
        generatedSetterHelperImpl(xsd, XSD$0, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "XSD" element
     */
    public io.github.isotes.vs.model.XSDDocument.XSD addNewXSD()
    {
        synchronized (monitor())
        {
            check_orphaned();
            io.github.isotes.vs.model.XSDDocument.XSD target = null;
            target = (io.github.isotes.vs.model.XSDDocument.XSD)get_store().add_element_user(XSD$0);
            return target;
        }
    }
    /**
     * An XML XSD(@http://schemas.microsoft.com/developer/msbuild/2003).
     *
     * This is a complex type.
     */
    public static class XSDImpl extends io.github.isotes.vs.model.impl.TaskTypeImpl implements io.github.isotes.vs.model.XSDDocument.XSD
    {
        private static final long serialVersionUID = 1L;
        
        public XSDImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName ACCEPTABLENONZEROEXITCODES$0 = 
            new javax.xml.namespace.QName("", "AcceptableNonZeroExitCodes");
        private static final javax.xml.namespace.QName ACTIVETOOLSWITCHESVALUES$2 = 
            new javax.xml.namespace.QName("", "ActiveToolSwitchesValues");
        private static final javax.xml.namespace.QName ADDITIONALOPTIONS$4 = 
            new javax.xml.namespace.QName("", "AdditionalOptions");
        private static final javax.xml.namespace.QName ENVIRONMENTVARIABLES$6 = 
            new javax.xml.namespace.QName("", "EnvironmentVariables");
        private static final javax.xml.namespace.QName EXCLUDEDINPUTPATHS$8 = 
            new javax.xml.namespace.QName("", "ExcludedInputPaths");
        private static final javax.xml.namespace.QName GENERATEFROMSCHEMA$10 = 
            new javax.xml.namespace.QName("", "GenerateFromSchema");
        private static final javax.xml.namespace.QName LANGUAGE$12 = 
            new javax.xml.namespace.QName("", "Language");
        private static final javax.xml.namespace.QName LOGSTANDARDERRORASERROR$14 = 
            new javax.xml.namespace.QName("", "LogStandardErrorAsError");
        private static final javax.xml.namespace.QName MINIMALREBUILDFROMTRACKING$16 = 
            new javax.xml.namespace.QName("", "MinimalRebuildFromTracking");
        private static final javax.xml.namespace.QName NAMESPACE$18 = 
            new javax.xml.namespace.QName("", "Namespace");
        private static final javax.xml.namespace.QName PATHOVERRIDE$20 = 
            new javax.xml.namespace.QName("", "PathOverride");
        private static final javax.xml.namespace.QName SKIPPEDEXECUTION$22 = 
            new javax.xml.namespace.QName("", "SkippedExecution");
        private static final javax.xml.namespace.QName SOURCES$24 = 
            new javax.xml.namespace.QName("", "Sources");
        private static final javax.xml.namespace.QName SOURCESCOMPILED$26 = 
            new javax.xml.namespace.QName("", "SourcesCompiled");
        private static final javax.xml.namespace.QName STANDARDERRORIMPORTANCE$28 = 
            new javax.xml.namespace.QName("", "StandardErrorImportance");
        private static final javax.xml.namespace.QName STANDARDOUTPUTIMPORTANCE$30 = 
            new javax.xml.namespace.QName("", "StandardOutputImportance");
        private static final javax.xml.namespace.QName SUPPRESSSTARTUPBANNER$32 = 
            new javax.xml.namespace.QName("", "SuppressStartupBanner");
        private static final javax.xml.namespace.QName TIMEOUT$34 = 
            new javax.xml.namespace.QName("", "Timeout");
        private static final javax.xml.namespace.QName TLOGREADFILES$36 = 
            new javax.xml.namespace.QName("", "TLogReadFiles");
        private static final javax.xml.namespace.QName TLOGWRITEFILES$38 = 
            new javax.xml.namespace.QName("", "TLogWriteFiles");
        private static final javax.xml.namespace.QName TOOLEXE$40 = 
            new javax.xml.namespace.QName("", "ToolExe");
        private static final javax.xml.namespace.QName TOOLPATH$42 = 
            new javax.xml.namespace.QName("", "ToolPath");
        private static final javax.xml.namespace.QName TRACKEDINPUTFILESTOIGNORE$44 = 
            new javax.xml.namespace.QName("", "TrackedInputFilesToIgnore");
        private static final javax.xml.namespace.QName TRACKEDOUTPUTFILESTOIGNORE$46 = 
            new javax.xml.namespace.QName("", "TrackedOutputFilesToIgnore");
        private static final javax.xml.namespace.QName TRACKERLOGDIRECTORY$48 = 
            new javax.xml.namespace.QName("", "TrackerLogDirectory");
        private static final javax.xml.namespace.QName TRACKFILEACCESS$50 = 
            new javax.xml.namespace.QName("", "TrackFileAccess");
        
        
        /**
         * Gets the "AcceptableNonZeroExitCodes" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getAcceptableNonZeroExitCodes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ACCEPTABLENONZEROEXITCODES$0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "AcceptableNonZeroExitCodes" attribute
         */
        public boolean isSetAcceptableNonZeroExitCodes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ACCEPTABLENONZEROEXITCODES$0) != null;
            }
        }
        
        /**
         * Sets the "AcceptableNonZeroExitCodes" attribute
         */
        public void setAcceptableNonZeroExitCodes(org.apache.xmlbeans.XmlAnySimpleType acceptableNonZeroExitCodes)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ACCEPTABLENONZEROEXITCODES$0);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ACCEPTABLENONZEROEXITCODES$0);
                }
                target.set(acceptableNonZeroExitCodes);
            }
        }
        
        /**
         * Appends and returns a new empty "AcceptableNonZeroExitCodes" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewAcceptableNonZeroExitCodes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ACCEPTABLENONZEROEXITCODES$0);
                return target;
            }
        }
        
        /**
         * Unsets the "AcceptableNonZeroExitCodes" attribute
         */
        public void unsetAcceptableNonZeroExitCodes()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ACCEPTABLENONZEROEXITCODES$0);
            }
        }
        
        /**
         * Gets the "ActiveToolSwitchesValues" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getActiveToolSwitchesValues()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ACTIVETOOLSWITCHESVALUES$2);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ActiveToolSwitchesValues" attribute
         */
        public boolean isSetActiveToolSwitchesValues()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ACTIVETOOLSWITCHESVALUES$2) != null;
            }
        }
        
        /**
         * Sets the "ActiveToolSwitchesValues" attribute
         */
        public void setActiveToolSwitchesValues(org.apache.xmlbeans.XmlAnySimpleType activeToolSwitchesValues)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ACTIVETOOLSWITCHESVALUES$2);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ACTIVETOOLSWITCHESVALUES$2);
                }
                target.set(activeToolSwitchesValues);
            }
        }
        
        /**
         * Appends and returns a new empty "ActiveToolSwitchesValues" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewActiveToolSwitchesValues()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ACTIVETOOLSWITCHESVALUES$2);
                return target;
            }
        }
        
        /**
         * Unsets the "ActiveToolSwitchesValues" attribute
         */
        public void unsetActiveToolSwitchesValues()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ACTIVETOOLSWITCHESVALUES$2);
            }
        }
        
        /**
         * Gets the "AdditionalOptions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getAdditionalOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALOPTIONS$4);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "AdditionalOptions" attribute
         */
        public boolean isSetAdditionalOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ADDITIONALOPTIONS$4) != null;
            }
        }
        
        /**
         * Sets the "AdditionalOptions" attribute
         */
        public void setAdditionalOptions(org.apache.xmlbeans.XmlAnySimpleType additionalOptions)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALOPTIONS$4);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALOPTIONS$4);
                }
                target.set(additionalOptions);
            }
        }
        
        /**
         * Appends and returns a new empty "AdditionalOptions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewAdditionalOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALOPTIONS$4);
                return target;
            }
        }
        
        /**
         * Unsets the "AdditionalOptions" attribute
         */
        public void unsetAdditionalOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ADDITIONALOPTIONS$4);
            }
        }
        
        /**
         * Gets the "EnvironmentVariables" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getEnvironmentVariables()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ENVIRONMENTVARIABLES$6);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "EnvironmentVariables" attribute
         */
        public boolean isSetEnvironmentVariables()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ENVIRONMENTVARIABLES$6) != null;
            }
        }
        
        /**
         * Sets the "EnvironmentVariables" attribute
         */
        public void setEnvironmentVariables(org.apache.xmlbeans.XmlAnySimpleType environmentVariables)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ENVIRONMENTVARIABLES$6);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ENVIRONMENTVARIABLES$6);
                }
                target.set(environmentVariables);
            }
        }
        
        /**
         * Appends and returns a new empty "EnvironmentVariables" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewEnvironmentVariables()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ENVIRONMENTVARIABLES$6);
                return target;
            }
        }
        
        /**
         * Unsets the "EnvironmentVariables" attribute
         */
        public void unsetEnvironmentVariables()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ENVIRONMENTVARIABLES$6);
            }
        }
        
        /**
         * Gets the "ExcludedInputPaths" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getExcludedInputPaths()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(EXCLUDEDINPUTPATHS$8);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ExcludedInputPaths" attribute
         */
        public boolean isSetExcludedInputPaths()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(EXCLUDEDINPUTPATHS$8) != null;
            }
        }
        
        /**
         * Sets the "ExcludedInputPaths" attribute
         */
        public void setExcludedInputPaths(org.apache.xmlbeans.XmlAnySimpleType excludedInputPaths)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(EXCLUDEDINPUTPATHS$8);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(EXCLUDEDINPUTPATHS$8);
                }
                target.set(excludedInputPaths);
            }
        }
        
        /**
         * Appends and returns a new empty "ExcludedInputPaths" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewExcludedInputPaths()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(EXCLUDEDINPUTPATHS$8);
                return target;
            }
        }
        
        /**
         * Unsets the "ExcludedInputPaths" attribute
         */
        public void unsetExcludedInputPaths()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(EXCLUDEDINPUTPATHS$8);
            }
        }
        
        /**
         * Gets the "GenerateFromSchema" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getGenerateFromSchema()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(GENERATEFROMSCHEMA$10);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "GenerateFromSchema" attribute
         */
        public boolean isSetGenerateFromSchema()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(GENERATEFROMSCHEMA$10) != null;
            }
        }
        
        /**
         * Sets the "GenerateFromSchema" attribute
         */
        public void setGenerateFromSchema(org.apache.xmlbeans.XmlAnySimpleType generateFromSchema)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(GENERATEFROMSCHEMA$10);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(GENERATEFROMSCHEMA$10);
                }
                target.set(generateFromSchema);
            }
        }
        
        /**
         * Appends and returns a new empty "GenerateFromSchema" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewGenerateFromSchema()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(GENERATEFROMSCHEMA$10);
                return target;
            }
        }
        
        /**
         * Unsets the "GenerateFromSchema" attribute
         */
        public void unsetGenerateFromSchema()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(GENERATEFROMSCHEMA$10);
            }
        }
        
        /**
         * Gets the "Language" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getLanguage()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(LANGUAGE$12);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Language" attribute
         */
        public boolean isSetLanguage()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(LANGUAGE$12) != null;
            }
        }
        
        /**
         * Sets the "Language" attribute
         */
        public void setLanguage(org.apache.xmlbeans.XmlAnySimpleType language)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(LANGUAGE$12);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(LANGUAGE$12);
                }
                target.set(language);
            }
        }
        
        /**
         * Appends and returns a new empty "Language" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewLanguage()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(LANGUAGE$12);
                return target;
            }
        }
        
        /**
         * Unsets the "Language" attribute
         */
        public void unsetLanguage()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(LANGUAGE$12);
            }
        }
        
        /**
         * Gets the "LogStandardErrorAsError" attribute
         */
        public java.lang.String getLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LOGSTANDARDERRORASERROR$14);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "LogStandardErrorAsError" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(LOGSTANDARDERRORASERROR$14);
                return target;
            }
        }
        
        /**
         * True if has "LogStandardErrorAsError" attribute
         */
        public boolean isSetLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(LOGSTANDARDERRORASERROR$14) != null;
            }
        }
        
        /**
         * Sets the "LogStandardErrorAsError" attribute
         */
        public void setLogStandardErrorAsError(java.lang.String logStandardErrorAsError)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LOGSTANDARDERRORASERROR$14);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(LOGSTANDARDERRORASERROR$14);
                }
                target.setStringValue(logStandardErrorAsError);
            }
        }
        
        /**
         * Sets (as xml) the "LogStandardErrorAsError" attribute
         */
        public void xsetLogStandardErrorAsError(io.github.isotes.vs.model.Boolean logStandardErrorAsError)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(LOGSTANDARDERRORASERROR$14);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(LOGSTANDARDERRORASERROR$14);
                }
                target.set(logStandardErrorAsError);
            }
        }
        
        /**
         * Unsets the "LogStandardErrorAsError" attribute
         */
        public void unsetLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(LOGSTANDARDERRORASERROR$14);
            }
        }
        
        /**
         * Gets the "MinimalRebuildFromTracking" attribute
         */
        public java.lang.String getMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$16);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "MinimalRebuildFromTracking" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$16);
                return target;
            }
        }
        
        /**
         * True if has "MinimalRebuildFromTracking" attribute
         */
        public boolean isSetMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$16) != null;
            }
        }
        
        /**
         * Sets the "MinimalRebuildFromTracking" attribute
         */
        public void setMinimalRebuildFromTracking(java.lang.String minimalRebuildFromTracking)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$16);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(MINIMALREBUILDFROMTRACKING$16);
                }
                target.setStringValue(minimalRebuildFromTracking);
            }
        }
        
        /**
         * Sets (as xml) the "MinimalRebuildFromTracking" attribute
         */
        public void xsetMinimalRebuildFromTracking(io.github.isotes.vs.model.Boolean minimalRebuildFromTracking)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$16);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(MINIMALREBUILDFROMTRACKING$16);
                }
                target.set(minimalRebuildFromTracking);
            }
        }
        
        /**
         * Unsets the "MinimalRebuildFromTracking" attribute
         */
        public void unsetMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(MINIMALREBUILDFROMTRACKING$16);
            }
        }
        
        /**
         * Gets the "Namespace" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getNamespace()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(NAMESPACE$18);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Namespace" attribute
         */
        public boolean isSetNamespace()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(NAMESPACE$18) != null;
            }
        }
        
        /**
         * Sets the "Namespace" attribute
         */
        public void setNamespace(org.apache.xmlbeans.XmlAnySimpleType namespace)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(NAMESPACE$18);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(NAMESPACE$18);
                }
                target.set(namespace);
            }
        }
        
        /**
         * Appends and returns a new empty "Namespace" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewNamespace()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(NAMESPACE$18);
                return target;
            }
        }
        
        /**
         * Unsets the "Namespace" attribute
         */
        public void unsetNamespace()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(NAMESPACE$18);
            }
        }
        
        /**
         * Gets the "PathOverride" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getPathOverride()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(PATHOVERRIDE$20);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "PathOverride" attribute
         */
        public boolean isSetPathOverride()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(PATHOVERRIDE$20) != null;
            }
        }
        
        /**
         * Sets the "PathOverride" attribute
         */
        public void setPathOverride(org.apache.xmlbeans.XmlAnySimpleType pathOverride)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(PATHOVERRIDE$20);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(PATHOVERRIDE$20);
                }
                target.set(pathOverride);
            }
        }
        
        /**
         * Appends and returns a new empty "PathOverride" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewPathOverride()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(PATHOVERRIDE$20);
                return target;
            }
        }
        
        /**
         * Unsets the "PathOverride" attribute
         */
        public void unsetPathOverride()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(PATHOVERRIDE$20);
            }
        }
        
        /**
         * Gets the "SkippedExecution" attribute
         */
        public java.lang.String getSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SKIPPEDEXECUTION$22);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "SkippedExecution" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SKIPPEDEXECUTION$22);
                return target;
            }
        }
        
        /**
         * True if has "SkippedExecution" attribute
         */
        public boolean isSetSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SKIPPEDEXECUTION$22) != null;
            }
        }
        
        /**
         * Sets the "SkippedExecution" attribute
         */
        public void setSkippedExecution(java.lang.String skippedExecution)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SKIPPEDEXECUTION$22);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SKIPPEDEXECUTION$22);
                }
                target.setStringValue(skippedExecution);
            }
        }
        
        /**
         * Sets (as xml) the "SkippedExecution" attribute
         */
        public void xsetSkippedExecution(io.github.isotes.vs.model.Boolean skippedExecution)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SKIPPEDEXECUTION$22);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(SKIPPEDEXECUTION$22);
                }
                target.set(skippedExecution);
            }
        }
        
        /**
         * Unsets the "SkippedExecution" attribute
         */
        public void unsetSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SKIPPEDEXECUTION$22);
            }
        }
        
        /**
         * Gets the "Sources" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getSources()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SOURCES$24);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * Sets the "Sources" attribute
         */
        public void setSources(org.apache.xmlbeans.XmlAnySimpleType sources)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SOURCES$24);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCES$24);
                }
                target.set(sources);
            }
        }
        
        /**
         * Appends and returns a new empty "Sources" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewSources()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCES$24);
                return target;
            }
        }
        
        /**
         * Gets the "SourcesCompiled" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getSourcesCompiled()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SOURCESCOMPILED$26);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "SourcesCompiled" attribute
         */
        public boolean isSetSourcesCompiled()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SOURCESCOMPILED$26) != null;
            }
        }
        
        /**
         * Sets the "SourcesCompiled" attribute
         */
        public void setSourcesCompiled(org.apache.xmlbeans.XmlAnySimpleType sourcesCompiled)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SOURCESCOMPILED$26);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCESCOMPILED$26);
                }
                target.set(sourcesCompiled);
            }
        }
        
        /**
         * Appends and returns a new empty "SourcesCompiled" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewSourcesCompiled()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCESCOMPILED$26);
                return target;
            }
        }
        
        /**
         * Unsets the "SourcesCompiled" attribute
         */
        public void unsetSourcesCompiled()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SOURCESCOMPILED$26);
            }
        }
        
        /**
         * Gets the "StandardErrorImportance" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getStandardErrorImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STANDARDERRORIMPORTANCE$28);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "StandardErrorImportance" attribute
         */
        public boolean isSetStandardErrorImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(STANDARDERRORIMPORTANCE$28) != null;
            }
        }
        
        /**
         * Sets the "StandardErrorImportance" attribute
         */
        public void setStandardErrorImportance(org.apache.xmlbeans.XmlAnySimpleType standardErrorImportance)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STANDARDERRORIMPORTANCE$28);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDERRORIMPORTANCE$28);
                }
                target.set(standardErrorImportance);
            }
        }
        
        /**
         * Appends and returns a new empty "StandardErrorImportance" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewStandardErrorImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDERRORIMPORTANCE$28);
                return target;
            }
        }
        
        /**
         * Unsets the "StandardErrorImportance" attribute
         */
        public void unsetStandardErrorImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(STANDARDERRORIMPORTANCE$28);
            }
        }
        
        /**
         * Gets the "StandardOutputImportance" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getStandardOutputImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STANDARDOUTPUTIMPORTANCE$30);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "StandardOutputImportance" attribute
         */
        public boolean isSetStandardOutputImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(STANDARDOUTPUTIMPORTANCE$30) != null;
            }
        }
        
        /**
         * Sets the "StandardOutputImportance" attribute
         */
        public void setStandardOutputImportance(org.apache.xmlbeans.XmlAnySimpleType standardOutputImportance)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(STANDARDOUTPUTIMPORTANCE$30);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDOUTPUTIMPORTANCE$30);
                }
                target.set(standardOutputImportance);
            }
        }
        
        /**
         * Appends and returns a new empty "StandardOutputImportance" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewStandardOutputImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDOUTPUTIMPORTANCE$30);
                return target;
            }
        }
        
        /**
         * Unsets the "StandardOutputImportance" attribute
         */
        public void unsetStandardOutputImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(STANDARDOUTPUTIMPORTANCE$30);
            }
        }
        
        /**
         * Gets the "SuppressStartupBanner" attribute
         */
        public java.lang.String getSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$32);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "SuppressStartupBanner" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$32);
                return target;
            }
        }
        
        /**
         * True if has "SuppressStartupBanner" attribute
         */
        public boolean isSetSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$32) != null;
            }
        }
        
        /**
         * Sets the "SuppressStartupBanner" attribute
         */
        public void setSuppressStartupBanner(java.lang.String suppressStartupBanner)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$32);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SUPPRESSSTARTUPBANNER$32);
                }
                target.setStringValue(suppressStartupBanner);
            }
        }
        
        /**
         * Sets (as xml) the "SuppressStartupBanner" attribute
         */
        public void xsetSuppressStartupBanner(io.github.isotes.vs.model.Boolean suppressStartupBanner)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$32);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(SUPPRESSSTARTUPBANNER$32);
                }
                target.set(suppressStartupBanner);
            }
        }
        
        /**
         * Unsets the "SuppressStartupBanner" attribute
         */
        public void unsetSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SUPPRESSSTARTUPBANNER$32);
            }
        }
        
        /**
         * Gets the "Timeout" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TIMEOUT$34);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "Timeout" attribute
         */
        public boolean isSetTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TIMEOUT$34) != null;
            }
        }
        
        /**
         * Sets the "Timeout" attribute
         */
        public void setTimeout(org.apache.xmlbeans.XmlAnySimpleType timeout)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TIMEOUT$34);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TIMEOUT$34);
                }
                target.set(timeout);
            }
        }
        
        /**
         * Appends and returns a new empty "Timeout" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TIMEOUT$34);
                return target;
            }
        }
        
        /**
         * Unsets the "Timeout" attribute
         */
        public void unsetTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TIMEOUT$34);
            }
        }
        
        /**
         * Gets the "TLogReadFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTLogReadFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TLOGREADFILES$36);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TLogReadFiles" attribute
         */
        public boolean isSetTLogReadFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TLOGREADFILES$36) != null;
            }
        }
        
        /**
         * Sets the "TLogReadFiles" attribute
         */
        public void setTLogReadFiles(org.apache.xmlbeans.XmlAnySimpleType tLogReadFiles)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TLOGREADFILES$36);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGREADFILES$36);
                }
                target.set(tLogReadFiles);
            }
        }
        
        /**
         * Appends and returns a new empty "TLogReadFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTLogReadFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGREADFILES$36);
                return target;
            }
        }
        
        /**
         * Unsets the "TLogReadFiles" attribute
         */
        public void unsetTLogReadFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TLOGREADFILES$36);
            }
        }
        
        /**
         * Gets the "TLogWriteFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTLogWriteFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TLOGWRITEFILES$38);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TLogWriteFiles" attribute
         */
        public boolean isSetTLogWriteFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TLOGWRITEFILES$38) != null;
            }
        }
        
        /**
         * Sets the "TLogWriteFiles" attribute
         */
        public void setTLogWriteFiles(org.apache.xmlbeans.XmlAnySimpleType tLogWriteFiles)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TLOGWRITEFILES$38);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGWRITEFILES$38);
                }
                target.set(tLogWriteFiles);
            }
        }
        
        /**
         * Appends and returns a new empty "TLogWriteFiles" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTLogWriteFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGWRITEFILES$38);
                return target;
            }
        }
        
        /**
         * Unsets the "TLogWriteFiles" attribute
         */
        public void unsetTLogWriteFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TLOGWRITEFILES$38);
            }
        }
        
        /**
         * Gets the "ToolExe" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getToolExe()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TOOLEXE$40);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ToolExe" attribute
         */
        public boolean isSetToolExe()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TOOLEXE$40) != null;
            }
        }
        
        /**
         * Sets the "ToolExe" attribute
         */
        public void setToolExe(org.apache.xmlbeans.XmlAnySimpleType toolExe)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TOOLEXE$40);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLEXE$40);
                }
                target.set(toolExe);
            }
        }
        
        /**
         * Appends and returns a new empty "ToolExe" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewToolExe()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLEXE$40);
                return target;
            }
        }
        
        /**
         * Unsets the "ToolExe" attribute
         */
        public void unsetToolExe()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TOOLEXE$40);
            }
        }
        
        /**
         * Gets the "ToolPath" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getToolPath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TOOLPATH$42);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ToolPath" attribute
         */
        public boolean isSetToolPath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TOOLPATH$42) != null;
            }
        }
        
        /**
         * Sets the "ToolPath" attribute
         */
        public void setToolPath(org.apache.xmlbeans.XmlAnySimpleType toolPath)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TOOLPATH$42);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLPATH$42);
                }
                target.set(toolPath);
            }
        }
        
        /**
         * Appends and returns a new empty "ToolPath" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewToolPath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLPATH$42);
                return target;
            }
        }
        
        /**
         * Unsets the "ToolPath" attribute
         */
        public void unsetToolPath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TOOLPATH$42);
            }
        }
        
        /**
         * Gets the "TrackedInputFilesToIgnore" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTrackedInputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKEDINPUTFILESTOIGNORE$44);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TrackedInputFilesToIgnore" attribute
         */
        public boolean isSetTrackedInputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TRACKEDINPUTFILESTOIGNORE$44) != null;
            }
        }
        
        /**
         * Sets the "TrackedInputFilesToIgnore" attribute
         */
        public void setTrackedInputFilesToIgnore(org.apache.xmlbeans.XmlAnySimpleType trackedInputFilesToIgnore)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKEDINPUTFILESTOIGNORE$44);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDINPUTFILESTOIGNORE$44);
                }
                target.set(trackedInputFilesToIgnore);
            }
        }
        
        /**
         * Appends and returns a new empty "TrackedInputFilesToIgnore" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTrackedInputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDINPUTFILESTOIGNORE$44);
                return target;
            }
        }
        
        /**
         * Unsets the "TrackedInputFilesToIgnore" attribute
         */
        public void unsetTrackedInputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKEDINPUTFILESTOIGNORE$44);
            }
        }
        
        /**
         * Gets the "TrackedOutputFilesToIgnore" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTrackedOutputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$46);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TrackedOutputFilesToIgnore" attribute
         */
        public boolean isSetTrackedOutputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$46) != null;
            }
        }
        
        /**
         * Sets the "TrackedOutputFilesToIgnore" attribute
         */
        public void setTrackedOutputFilesToIgnore(org.apache.xmlbeans.XmlAnySimpleType trackedOutputFilesToIgnore)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$46);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$46);
                }
                target.set(trackedOutputFilesToIgnore);
            }
        }
        
        /**
         * Appends and returns a new empty "TrackedOutputFilesToIgnore" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTrackedOutputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$46);
                return target;
            }
        }
        
        /**
         * Unsets the "TrackedOutputFilesToIgnore" attribute
         */
        public void unsetTrackedOutputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKEDOUTPUTFILESTOIGNORE$46);
            }
        }
        
        /**
         * Gets the "TrackerLogDirectory" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTrackerLogDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKERLOGDIRECTORY$48);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TrackerLogDirectory" attribute
         */
        public boolean isSetTrackerLogDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TRACKERLOGDIRECTORY$48) != null;
            }
        }
        
        /**
         * Sets the "TrackerLogDirectory" attribute
         */
        public void setTrackerLogDirectory(org.apache.xmlbeans.XmlAnySimpleType trackerLogDirectory)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TRACKERLOGDIRECTORY$48);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKERLOGDIRECTORY$48);
                }
                target.set(trackerLogDirectory);
            }
        }
        
        /**
         * Appends and returns a new empty "TrackerLogDirectory" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTrackerLogDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKERLOGDIRECTORY$48);
                return target;
            }
        }
        
        /**
         * Unsets the "TrackerLogDirectory" attribute
         */
        public void unsetTrackerLogDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKERLOGDIRECTORY$48);
            }
        }
        
        /**
         * Gets the "TrackFileAccess" attribute
         */
        public java.lang.String getTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TRACKFILEACCESS$50);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "TrackFileAccess" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(TRACKFILEACCESS$50);
                return target;
            }
        }
        
        /**
         * True if has "TrackFileAccess" attribute
         */
        public boolean isSetTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TRACKFILEACCESS$50) != null;
            }
        }
        
        /**
         * Sets the "TrackFileAccess" attribute
         */
        public void setTrackFileAccess(java.lang.String trackFileAccess)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TRACKFILEACCESS$50);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(TRACKFILEACCESS$50);
                }
                target.setStringValue(trackFileAccess);
            }
        }
        
        /**
         * Sets (as xml) the "TrackFileAccess" attribute
         */
        public void xsetTrackFileAccess(io.github.isotes.vs.model.Boolean trackFileAccess)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(TRACKFILEACCESS$50);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(TRACKFILEACCESS$50);
                }
                target.set(trackFileAccess);
            }
        }
        
        /**
         * Unsets the "TrackFileAccess" attribute
         */
        public void unsetTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKFILEACCESS$50);
            }
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy