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

io.github.isotes.vs.model.impl.LIBDocumentImpl 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: LIB
 * Namespace: http://schemas.microsoft.com/developer/msbuild/2003
 * Java type: io.github.isotes.vs.model.LIBDocument
 *
 * Automatically generated - do not modify.
 */
package io.github.isotes.vs.model.impl;
/**
 * A document containing one LIB(@http://schemas.microsoft.com/developer/msbuild/2003) element.
 *
 * This is a complex type.
 */
public class LIBDocumentImpl extends io.github.isotes.vs.model.impl.TaskDocumentImpl implements io.github.isotes.vs.model.LIBDocument
{
    private static final long serialVersionUID = 1L;
    
    public LIBDocumentImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName LIB$0 = 
        new javax.xml.namespace.QName("http://schemas.microsoft.com/developer/msbuild/2003", "LIB");
    
    
    /**
     * Gets the "LIB" element
     */
    public io.github.isotes.vs.model.LIBDocument.LIB getLIB()
    {
        synchronized (monitor())
        {
            check_orphaned();
            io.github.isotes.vs.model.LIBDocument.LIB target = null;
            target = (io.github.isotes.vs.model.LIBDocument.LIB)get_store().find_element_user(LIB$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * Sets the "LIB" element
     */
    public void setLIB(io.github.isotes.vs.model.LIBDocument.LIB lib)
    {
        generatedSetterHelperImpl(lib, LIB$0, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "LIB" element
     */
    public io.github.isotes.vs.model.LIBDocument.LIB addNewLIB()
    {
        synchronized (monitor())
        {
            check_orphaned();
            io.github.isotes.vs.model.LIBDocument.LIB target = null;
            target = (io.github.isotes.vs.model.LIBDocument.LIB)get_store().add_element_user(LIB$0);
            return target;
        }
    }
    /**
     * An XML LIB(@http://schemas.microsoft.com/developer/msbuild/2003).
     *
     * This is a complex type.
     */
    public static class LIBImpl extends io.github.isotes.vs.model.impl.TaskTypeImpl implements io.github.isotes.vs.model.LIBDocument.LIB
    {
        private static final long serialVersionUID = 1L;
        
        public LIBImpl(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 ADDITIONALDEPENDENCIES$4 = 
            new javax.xml.namespace.QName("", "AdditionalDependencies");
        private static final javax.xml.namespace.QName ADDITIONALLIBRARYDIRECTORIES$6 = 
            new javax.xml.namespace.QName("", "AdditionalLibraryDirectories");
        private static final javax.xml.namespace.QName ADDITIONALOPTIONS$8 = 
            new javax.xml.namespace.QName("", "AdditionalOptions");
        private static final javax.xml.namespace.QName DISPLAYLIBRARY$10 = 
            new javax.xml.namespace.QName("", "DisplayLibrary");
        private static final javax.xml.namespace.QName ENVIRONMENTVARIABLES$12 = 
            new javax.xml.namespace.QName("", "EnvironmentVariables");
        private static final javax.xml.namespace.QName ERRORREPORTING$14 = 
            new javax.xml.namespace.QName("", "ErrorReporting");
        private static final javax.xml.namespace.QName EXCLUDEDINPUTPATHS$16 = 
            new javax.xml.namespace.QName("", "ExcludedInputPaths");
        private static final javax.xml.namespace.QName EXPORTNAMEDFUNCTIONS$18 = 
            new javax.xml.namespace.QName("", "ExportNamedFunctions");
        private static final javax.xml.namespace.QName FORCESYMBOLREFERENCES$20 = 
            new javax.xml.namespace.QName("", "ForceSymbolReferences");
        private static final javax.xml.namespace.QName IGNOREALLDEFAULTLIBRARIES$22 = 
            new javax.xml.namespace.QName("", "IgnoreAllDefaultLibraries");
        private static final javax.xml.namespace.QName IGNORESPECIFICDEFAULTLIBRARIES$24 = 
            new javax.xml.namespace.QName("", "IgnoreSpecificDefaultLibraries");
        private static final javax.xml.namespace.QName LINKLIBRARYDEPENDENCIES$26 = 
            new javax.xml.namespace.QName("", "LinkLibraryDependencies");
        private static final javax.xml.namespace.QName LINKTIMECODEGENERATION$28 = 
            new javax.xml.namespace.QName("", "LinkTimeCodeGeneration");
        private static final javax.xml.namespace.QName LOGSTANDARDERRORASERROR$30 = 
            new javax.xml.namespace.QName("", "LogStandardErrorAsError");
        private static final javax.xml.namespace.QName MINIMALREBUILDFROMTRACKING$32 = 
            new javax.xml.namespace.QName("", "MinimalRebuildFromTracking");
        private static final javax.xml.namespace.QName MINIMUMREQUIREDVERSION$34 = 
            new javax.xml.namespace.QName("", "MinimumRequiredVersion");
        private static final javax.xml.namespace.QName MODULEDEFINITIONFILE$36 = 
            new javax.xml.namespace.QName("", "ModuleDefinitionFile");
        private static final javax.xml.namespace.QName OUTPUTFILE$38 = 
            new javax.xml.namespace.QName("", "OutputFile");
        private static final javax.xml.namespace.QName PATHOVERRIDE$40 = 
            new javax.xml.namespace.QName("", "PathOverride");
        private static final javax.xml.namespace.QName REMOVEOBJECTS$42 = 
            new javax.xml.namespace.QName("", "RemoveObjects");
        private static final javax.xml.namespace.QName SKIPPEDEXECUTION$44 = 
            new javax.xml.namespace.QName("", "SkippedExecution");
        private static final javax.xml.namespace.QName SOURCES$46 = 
            new javax.xml.namespace.QName("", "Sources");
        private static final javax.xml.namespace.QName SOURCESCOMPILED$48 = 
            new javax.xml.namespace.QName("", "SourcesCompiled");
        private static final javax.xml.namespace.QName STANDARDERRORIMPORTANCE$50 = 
            new javax.xml.namespace.QName("", "StandardErrorImportance");
        private static final javax.xml.namespace.QName STANDARDOUTPUTIMPORTANCE$52 = 
            new javax.xml.namespace.QName("", "StandardOutputImportance");
        private static final javax.xml.namespace.QName SUBSYSTEM$54 = 
            new javax.xml.namespace.QName("", "SubSystem");
        private static final javax.xml.namespace.QName SUPPRESSSTARTUPBANNER$56 = 
            new javax.xml.namespace.QName("", "SuppressStartupBanner");
        private static final javax.xml.namespace.QName TARGETMACHINE$58 = 
            new javax.xml.namespace.QName("", "TargetMachine");
        private static final javax.xml.namespace.QName TIMEOUT$60 = 
            new javax.xml.namespace.QName("", "Timeout");
        private static final javax.xml.namespace.QName TLOGREADFILES$62 = 
            new javax.xml.namespace.QName("", "TLogReadFiles");
        private static final javax.xml.namespace.QName TLOGWRITEFILES$64 = 
            new javax.xml.namespace.QName("", "TLogWriteFiles");
        private static final javax.xml.namespace.QName TOOLEXE$66 = 
            new javax.xml.namespace.QName("", "ToolExe");
        private static final javax.xml.namespace.QName TOOLPATH$68 = 
            new javax.xml.namespace.QName("", "ToolPath");
        private static final javax.xml.namespace.QName TRACKEDINPUTFILESTOIGNORE$70 = 
            new javax.xml.namespace.QName("", "TrackedInputFilesToIgnore");
        private static final javax.xml.namespace.QName TRACKEDOUTPUTFILESTOIGNORE$72 = 
            new javax.xml.namespace.QName("", "TrackedOutputFilesToIgnore");
        private static final javax.xml.namespace.QName TRACKERLOGDIRECTORY$74 = 
            new javax.xml.namespace.QName("", "TrackerLogDirectory");
        private static final javax.xml.namespace.QName TRACKFILEACCESS$76 = 
            new javax.xml.namespace.QName("", "TrackFileAccess");
        private static final javax.xml.namespace.QName TREATLIBWARNINGASERRORS$78 = 
            new javax.xml.namespace.QName("", "TreatLibWarningAsErrors");
        private static final javax.xml.namespace.QName USEUNICODERESPONSEFILES$80 = 
            new javax.xml.namespace.QName("", "UseUnicodeResponseFiles");
        private static final javax.xml.namespace.QName VERBOSE$82 = 
            new javax.xml.namespace.QName("", "Verbose");
        
        
        /**
         * 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 "AdditionalDependencies" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getAdditionalDependencies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALDEPENDENCIES$4);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "AdditionalDependencies" attribute
         */
        public boolean isSetAdditionalDependencies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ADDITIONALDEPENDENCIES$4) != null;
            }
        }
        
        /**
         * Sets the "AdditionalDependencies" attribute
         */
        public void setAdditionalDependencies(org.apache.xmlbeans.XmlAnySimpleType additionalDependencies)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALDEPENDENCIES$4);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALDEPENDENCIES$4);
                }
                target.set(additionalDependencies);
            }
        }
        
        /**
         * Appends and returns a new empty "AdditionalDependencies" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewAdditionalDependencies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALDEPENDENCIES$4);
                return target;
            }
        }
        
        /**
         * Unsets the "AdditionalDependencies" attribute
         */
        public void unsetAdditionalDependencies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ADDITIONALDEPENDENCIES$4);
            }
        }
        
        /**
         * Gets the "AdditionalLibraryDirectories" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getAdditionalLibraryDirectories()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALLIBRARYDIRECTORIES$6);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "AdditionalLibraryDirectories" attribute
         */
        public boolean isSetAdditionalLibraryDirectories()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ADDITIONALLIBRARYDIRECTORIES$6) != null;
            }
        }
        
        /**
         * Sets the "AdditionalLibraryDirectories" attribute
         */
        public void setAdditionalLibraryDirectories(org.apache.xmlbeans.XmlAnySimpleType additionalLibraryDirectories)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ADDITIONALLIBRARYDIRECTORIES$6);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALLIBRARYDIRECTORIES$6);
                }
                target.set(additionalLibraryDirectories);
            }
        }
        
        /**
         * Appends and returns a new empty "AdditionalLibraryDirectories" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewAdditionalLibraryDirectories()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALLIBRARYDIRECTORIES$6);
                return target;
            }
        }
        
        /**
         * Unsets the "AdditionalLibraryDirectories" attribute
         */
        public void unsetAdditionalLibraryDirectories()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ADDITIONALLIBRARYDIRECTORIES$6);
            }
        }
        
        /**
         * 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$8);
                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$8) != 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$8);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ADDITIONALOPTIONS$8);
                }
                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$8);
                return target;
            }
        }
        
        /**
         * Unsets the "AdditionalOptions" attribute
         */
        public void unsetAdditionalOptions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ADDITIONALOPTIONS$8);
            }
        }
        
        /**
         * Gets the "DisplayLibrary" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getDisplayLibrary()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(DISPLAYLIBRARY$10);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "DisplayLibrary" attribute
         */
        public boolean isSetDisplayLibrary()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(DISPLAYLIBRARY$10) != null;
            }
        }
        
        /**
         * Sets the "DisplayLibrary" attribute
         */
        public void setDisplayLibrary(org.apache.xmlbeans.XmlAnySimpleType displayLibrary)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(DISPLAYLIBRARY$10);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(DISPLAYLIBRARY$10);
                }
                target.set(displayLibrary);
            }
        }
        
        /**
         * Appends and returns a new empty "DisplayLibrary" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewDisplayLibrary()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(DISPLAYLIBRARY$10);
                return target;
            }
        }
        
        /**
         * Unsets the "DisplayLibrary" attribute
         */
        public void unsetDisplayLibrary()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(DISPLAYLIBRARY$10);
            }
        }
        
        /**
         * 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$12);
                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$12) != 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$12);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ENVIRONMENTVARIABLES$12);
                }
                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$12);
                return target;
            }
        }
        
        /**
         * Unsets the "EnvironmentVariables" attribute
         */
        public void unsetEnvironmentVariables()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ENVIRONMENTVARIABLES$12);
            }
        }
        
        /**
         * Gets the "ErrorReporting" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getErrorReporting()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ERRORREPORTING$14);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ErrorReporting" attribute
         */
        public boolean isSetErrorReporting()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ERRORREPORTING$14) != null;
            }
        }
        
        /**
         * Sets the "ErrorReporting" attribute
         */
        public void setErrorReporting(org.apache.xmlbeans.XmlAnySimpleType errorReporting)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(ERRORREPORTING$14);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ERRORREPORTING$14);
                }
                target.set(errorReporting);
            }
        }
        
        /**
         * Appends and returns a new empty "ErrorReporting" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewErrorReporting()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(ERRORREPORTING$14);
                return target;
            }
        }
        
        /**
         * Unsets the "ErrorReporting" attribute
         */
        public void unsetErrorReporting()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ERRORREPORTING$14);
            }
        }
        
        /**
         * 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$16);
                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$16) != 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$16);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(EXCLUDEDINPUTPATHS$16);
                }
                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$16);
                return target;
            }
        }
        
        /**
         * Unsets the "ExcludedInputPaths" attribute
         */
        public void unsetExcludedInputPaths()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(EXCLUDEDINPUTPATHS$16);
            }
        }
        
        /**
         * Gets the "ExportNamedFunctions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getExportNamedFunctions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(EXPORTNAMEDFUNCTIONS$18);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ExportNamedFunctions" attribute
         */
        public boolean isSetExportNamedFunctions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(EXPORTNAMEDFUNCTIONS$18) != null;
            }
        }
        
        /**
         * Sets the "ExportNamedFunctions" attribute
         */
        public void setExportNamedFunctions(org.apache.xmlbeans.XmlAnySimpleType exportNamedFunctions)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(EXPORTNAMEDFUNCTIONS$18);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(EXPORTNAMEDFUNCTIONS$18);
                }
                target.set(exportNamedFunctions);
            }
        }
        
        /**
         * Appends and returns a new empty "ExportNamedFunctions" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewExportNamedFunctions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(EXPORTNAMEDFUNCTIONS$18);
                return target;
            }
        }
        
        /**
         * Unsets the "ExportNamedFunctions" attribute
         */
        public void unsetExportNamedFunctions()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(EXPORTNAMEDFUNCTIONS$18);
            }
        }
        
        /**
         * Gets the "ForceSymbolReferences" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getForceSymbolReferences()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(FORCESYMBOLREFERENCES$20);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ForceSymbolReferences" attribute
         */
        public boolean isSetForceSymbolReferences()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(FORCESYMBOLREFERENCES$20) != null;
            }
        }
        
        /**
         * Sets the "ForceSymbolReferences" attribute
         */
        public void setForceSymbolReferences(org.apache.xmlbeans.XmlAnySimpleType forceSymbolReferences)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(FORCESYMBOLREFERENCES$20);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(FORCESYMBOLREFERENCES$20);
                }
                target.set(forceSymbolReferences);
            }
        }
        
        /**
         * Appends and returns a new empty "ForceSymbolReferences" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewForceSymbolReferences()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(FORCESYMBOLREFERENCES$20);
                return target;
            }
        }
        
        /**
         * Unsets the "ForceSymbolReferences" attribute
         */
        public void unsetForceSymbolReferences()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(FORCESYMBOLREFERENCES$20);
            }
        }
        
        /**
         * Gets the "IgnoreAllDefaultLibraries" attribute
         */
        public java.lang.String getIgnoreAllDefaultLibraries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(IGNOREALLDEFAULTLIBRARIES$22);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "IgnoreAllDefaultLibraries" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetIgnoreAllDefaultLibraries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(IGNOREALLDEFAULTLIBRARIES$22);
                return target;
            }
        }
        
        /**
         * True if has "IgnoreAllDefaultLibraries" attribute
         */
        public boolean isSetIgnoreAllDefaultLibraries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(IGNOREALLDEFAULTLIBRARIES$22) != null;
            }
        }
        
        /**
         * Sets the "IgnoreAllDefaultLibraries" attribute
         */
        public void setIgnoreAllDefaultLibraries(java.lang.String ignoreAllDefaultLibraries)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(IGNOREALLDEFAULTLIBRARIES$22);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(IGNOREALLDEFAULTLIBRARIES$22);
                }
                target.setStringValue(ignoreAllDefaultLibraries);
            }
        }
        
        /**
         * Sets (as xml) the "IgnoreAllDefaultLibraries" attribute
         */
        public void xsetIgnoreAllDefaultLibraries(io.github.isotes.vs.model.Boolean ignoreAllDefaultLibraries)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(IGNOREALLDEFAULTLIBRARIES$22);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(IGNOREALLDEFAULTLIBRARIES$22);
                }
                target.set(ignoreAllDefaultLibraries);
            }
        }
        
        /**
         * Unsets the "IgnoreAllDefaultLibraries" attribute
         */
        public void unsetIgnoreAllDefaultLibraries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(IGNOREALLDEFAULTLIBRARIES$22);
            }
        }
        
        /**
         * Gets the "IgnoreSpecificDefaultLibraries" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getIgnoreSpecificDefaultLibraries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(IGNORESPECIFICDEFAULTLIBRARIES$24);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "IgnoreSpecificDefaultLibraries" attribute
         */
        public boolean isSetIgnoreSpecificDefaultLibraries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(IGNORESPECIFICDEFAULTLIBRARIES$24) != null;
            }
        }
        
        /**
         * Sets the "IgnoreSpecificDefaultLibraries" attribute
         */
        public void setIgnoreSpecificDefaultLibraries(org.apache.xmlbeans.XmlAnySimpleType ignoreSpecificDefaultLibraries)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(IGNORESPECIFICDEFAULTLIBRARIES$24);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(IGNORESPECIFICDEFAULTLIBRARIES$24);
                }
                target.set(ignoreSpecificDefaultLibraries);
            }
        }
        
        /**
         * Appends and returns a new empty "IgnoreSpecificDefaultLibraries" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewIgnoreSpecificDefaultLibraries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(IGNORESPECIFICDEFAULTLIBRARIES$24);
                return target;
            }
        }
        
        /**
         * Unsets the "IgnoreSpecificDefaultLibraries" attribute
         */
        public void unsetIgnoreSpecificDefaultLibraries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(IGNORESPECIFICDEFAULTLIBRARIES$24);
            }
        }
        
        /**
         * Gets the "LinkLibraryDependencies" attribute
         */
        public java.lang.String getLinkLibraryDependencies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LINKLIBRARYDEPENDENCIES$26);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "LinkLibraryDependencies" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetLinkLibraryDependencies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(LINKLIBRARYDEPENDENCIES$26);
                return target;
            }
        }
        
        /**
         * True if has "LinkLibraryDependencies" attribute
         */
        public boolean isSetLinkLibraryDependencies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(LINKLIBRARYDEPENDENCIES$26) != null;
            }
        }
        
        /**
         * Sets the "LinkLibraryDependencies" attribute
         */
        public void setLinkLibraryDependencies(java.lang.String linkLibraryDependencies)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LINKLIBRARYDEPENDENCIES$26);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(LINKLIBRARYDEPENDENCIES$26);
                }
                target.setStringValue(linkLibraryDependencies);
            }
        }
        
        /**
         * Sets (as xml) the "LinkLibraryDependencies" attribute
         */
        public void xsetLinkLibraryDependencies(io.github.isotes.vs.model.Boolean linkLibraryDependencies)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(LINKLIBRARYDEPENDENCIES$26);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(LINKLIBRARYDEPENDENCIES$26);
                }
                target.set(linkLibraryDependencies);
            }
        }
        
        /**
         * Unsets the "LinkLibraryDependencies" attribute
         */
        public void unsetLinkLibraryDependencies()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(LINKLIBRARYDEPENDENCIES$26);
            }
        }
        
        /**
         * Gets the "LinkTimeCodeGeneration" attribute
         */
        public java.lang.String getLinkTimeCodeGeneration()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LINKTIMECODEGENERATION$28);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "LinkTimeCodeGeneration" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetLinkTimeCodeGeneration()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(LINKTIMECODEGENERATION$28);
                return target;
            }
        }
        
        /**
         * True if has "LinkTimeCodeGeneration" attribute
         */
        public boolean isSetLinkTimeCodeGeneration()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(LINKTIMECODEGENERATION$28) != null;
            }
        }
        
        /**
         * Sets the "LinkTimeCodeGeneration" attribute
         */
        public void setLinkTimeCodeGeneration(java.lang.String linkTimeCodeGeneration)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LINKTIMECODEGENERATION$28);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(LINKTIMECODEGENERATION$28);
                }
                target.setStringValue(linkTimeCodeGeneration);
            }
        }
        
        /**
         * Sets (as xml) the "LinkTimeCodeGeneration" attribute
         */
        public void xsetLinkTimeCodeGeneration(io.github.isotes.vs.model.Boolean linkTimeCodeGeneration)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(LINKTIMECODEGENERATION$28);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(LINKTIMECODEGENERATION$28);
                }
                target.set(linkTimeCodeGeneration);
            }
        }
        
        /**
         * Unsets the "LinkTimeCodeGeneration" attribute
         */
        public void unsetLinkTimeCodeGeneration()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(LINKTIMECODEGENERATION$28);
            }
        }
        
        /**
         * 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$30);
                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$30);
                return target;
            }
        }
        
        /**
         * True if has "LogStandardErrorAsError" attribute
         */
        public boolean isSetLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(LOGSTANDARDERRORASERROR$30) != 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$30);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(LOGSTANDARDERRORASERROR$30);
                }
                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$30);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(LOGSTANDARDERRORASERROR$30);
                }
                target.set(logStandardErrorAsError);
            }
        }
        
        /**
         * Unsets the "LogStandardErrorAsError" attribute
         */
        public void unsetLogStandardErrorAsError()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(LOGSTANDARDERRORASERROR$30);
            }
        }
        
        /**
         * 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$32);
                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$32);
                return target;
            }
        }
        
        /**
         * True if has "MinimalRebuildFromTracking" attribute
         */
        public boolean isSetMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(MINIMALREBUILDFROMTRACKING$32) != 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$32);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(MINIMALREBUILDFROMTRACKING$32);
                }
                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$32);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(MINIMALREBUILDFROMTRACKING$32);
                }
                target.set(minimalRebuildFromTracking);
            }
        }
        
        /**
         * Unsets the "MinimalRebuildFromTracking" attribute
         */
        public void unsetMinimalRebuildFromTracking()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(MINIMALREBUILDFROMTRACKING$32);
            }
        }
        
        /**
         * Gets the "MinimumRequiredVersion" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getMinimumRequiredVersion()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(MINIMUMREQUIREDVERSION$34);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "MinimumRequiredVersion" attribute
         */
        public boolean isSetMinimumRequiredVersion()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(MINIMUMREQUIREDVERSION$34) != null;
            }
        }
        
        /**
         * Sets the "MinimumRequiredVersion" attribute
         */
        public void setMinimumRequiredVersion(org.apache.xmlbeans.XmlAnySimpleType minimumRequiredVersion)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(MINIMUMREQUIREDVERSION$34);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(MINIMUMREQUIREDVERSION$34);
                }
                target.set(minimumRequiredVersion);
            }
        }
        
        /**
         * Appends and returns a new empty "MinimumRequiredVersion" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewMinimumRequiredVersion()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(MINIMUMREQUIREDVERSION$34);
                return target;
            }
        }
        
        /**
         * Unsets the "MinimumRequiredVersion" attribute
         */
        public void unsetMinimumRequiredVersion()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(MINIMUMREQUIREDVERSION$34);
            }
        }
        
        /**
         * Gets the "ModuleDefinitionFile" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getModuleDefinitionFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(MODULEDEFINITIONFILE$36);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "ModuleDefinitionFile" attribute
         */
        public boolean isSetModuleDefinitionFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(MODULEDEFINITIONFILE$36) != null;
            }
        }
        
        /**
         * Sets the "ModuleDefinitionFile" attribute
         */
        public void setModuleDefinitionFile(org.apache.xmlbeans.XmlAnySimpleType moduleDefinitionFile)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(MODULEDEFINITIONFILE$36);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(MODULEDEFINITIONFILE$36);
                }
                target.set(moduleDefinitionFile);
            }
        }
        
        /**
         * Appends and returns a new empty "ModuleDefinitionFile" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewModuleDefinitionFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(MODULEDEFINITIONFILE$36);
                return target;
            }
        }
        
        /**
         * Unsets the "ModuleDefinitionFile" attribute
         */
        public void unsetModuleDefinitionFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(MODULEDEFINITIONFILE$36);
            }
        }
        
        /**
         * Gets the "OutputFile" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getOutputFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(OUTPUTFILE$38);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "OutputFile" attribute
         */
        public boolean isSetOutputFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(OUTPUTFILE$38) != null;
            }
        }
        
        /**
         * Sets the "OutputFile" attribute
         */
        public void setOutputFile(org.apache.xmlbeans.XmlAnySimpleType outputFile)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(OUTPUTFILE$38);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(OUTPUTFILE$38);
                }
                target.set(outputFile);
            }
        }
        
        /**
         * Appends and returns a new empty "OutputFile" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewOutputFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(OUTPUTFILE$38);
                return target;
            }
        }
        
        /**
         * Unsets the "OutputFile" attribute
         */
        public void unsetOutputFile()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(OUTPUTFILE$38);
            }
        }
        
        /**
         * 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$40);
                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$40) != 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$40);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(PATHOVERRIDE$40);
                }
                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$40);
                return target;
            }
        }
        
        /**
         * Unsets the "PathOverride" attribute
         */
        public void unsetPathOverride()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(PATHOVERRIDE$40);
            }
        }
        
        /**
         * Gets the "RemoveObjects" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getRemoveObjects()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(REMOVEOBJECTS$42);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "RemoveObjects" attribute
         */
        public boolean isSetRemoveObjects()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(REMOVEOBJECTS$42) != null;
            }
        }
        
        /**
         * Sets the "RemoveObjects" attribute
         */
        public void setRemoveObjects(org.apache.xmlbeans.XmlAnySimpleType removeObjects)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(REMOVEOBJECTS$42);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(REMOVEOBJECTS$42);
                }
                target.set(removeObjects);
            }
        }
        
        /**
         * Appends and returns a new empty "RemoveObjects" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewRemoveObjects()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(REMOVEOBJECTS$42);
                return target;
            }
        }
        
        /**
         * Unsets the "RemoveObjects" attribute
         */
        public void unsetRemoveObjects()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(REMOVEOBJECTS$42);
            }
        }
        
        /**
         * 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$44);
                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$44);
                return target;
            }
        }
        
        /**
         * True if has "SkippedExecution" attribute
         */
        public boolean isSetSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SKIPPEDEXECUTION$44) != 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$44);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SKIPPEDEXECUTION$44);
                }
                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$44);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(SKIPPEDEXECUTION$44);
                }
                target.set(skippedExecution);
            }
        }
        
        /**
         * Unsets the "SkippedExecution" attribute
         */
        public void unsetSkippedExecution()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SKIPPEDEXECUTION$44);
            }
        }
        
        /**
         * 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$46);
                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$46);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCES$46);
                }
                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$46);
                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$48);
                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$48) != 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$48);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SOURCESCOMPILED$48);
                }
                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$48);
                return target;
            }
        }
        
        /**
         * Unsets the "SourcesCompiled" attribute
         */
        public void unsetSourcesCompiled()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SOURCESCOMPILED$48);
            }
        }
        
        /**
         * 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$50);
                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$50) != 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$50);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDERRORIMPORTANCE$50);
                }
                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$50);
                return target;
            }
        }
        
        /**
         * Unsets the "StandardErrorImportance" attribute
         */
        public void unsetStandardErrorImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(STANDARDERRORIMPORTANCE$50);
            }
        }
        
        /**
         * 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$52);
                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$52) != 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$52);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(STANDARDOUTPUTIMPORTANCE$52);
                }
                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$52);
                return target;
            }
        }
        
        /**
         * Unsets the "StandardOutputImportance" attribute
         */
        public void unsetStandardOutputImportance()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(STANDARDOUTPUTIMPORTANCE$52);
            }
        }
        
        /**
         * Gets the "SubSystem" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getSubSystem()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SUBSYSTEM$54);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "SubSystem" attribute
         */
        public boolean isSetSubSystem()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SUBSYSTEM$54) != null;
            }
        }
        
        /**
         * Sets the "SubSystem" attribute
         */
        public void setSubSystem(org.apache.xmlbeans.XmlAnySimpleType subSystem)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(SUBSYSTEM$54);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SUBSYSTEM$54);
                }
                target.set(subSystem);
            }
        }
        
        /**
         * Appends and returns a new empty "SubSystem" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewSubSystem()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(SUBSYSTEM$54);
                return target;
            }
        }
        
        /**
         * Unsets the "SubSystem" attribute
         */
        public void unsetSubSystem()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SUBSYSTEM$54);
            }
        }
        
        /**
         * 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$56);
                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$56);
                return target;
            }
        }
        
        /**
         * True if has "SuppressStartupBanner" attribute
         */
        public boolean isSetSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SUPPRESSSTARTUPBANNER$56) != 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$56);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SUPPRESSSTARTUPBANNER$56);
                }
                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$56);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(SUPPRESSSTARTUPBANNER$56);
                }
                target.set(suppressStartupBanner);
            }
        }
        
        /**
         * Unsets the "SuppressStartupBanner" attribute
         */
        public void unsetSuppressStartupBanner()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SUPPRESSSTARTUPBANNER$56);
            }
        }
        
        /**
         * Gets the "TargetMachine" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType getTargetMachine()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TARGETMACHINE$58);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "TargetMachine" attribute
         */
        public boolean isSetTargetMachine()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TARGETMACHINE$58) != null;
            }
        }
        
        /**
         * Sets the "TargetMachine" attribute
         */
        public void setTargetMachine(org.apache.xmlbeans.XmlAnySimpleType targetMachine)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().find_attribute_user(TARGETMACHINE$58);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TARGETMACHINE$58);
                }
                target.set(targetMachine);
            }
        }
        
        /**
         * Appends and returns a new empty "TargetMachine" attribute
         */
        public org.apache.xmlbeans.XmlAnySimpleType addNewTargetMachine()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlAnySimpleType target = null;
                target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TARGETMACHINE$58);
                return target;
            }
        }
        
        /**
         * Unsets the "TargetMachine" attribute
         */
        public void unsetTargetMachine()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TARGETMACHINE$58);
            }
        }
        
        /**
         * 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$60);
                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$60) != 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$60);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TIMEOUT$60);
                }
                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$60);
                return target;
            }
        }
        
        /**
         * Unsets the "Timeout" attribute
         */
        public void unsetTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TIMEOUT$60);
            }
        }
        
        /**
         * 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$62);
                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$62) != 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$62);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGREADFILES$62);
                }
                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$62);
                return target;
            }
        }
        
        /**
         * Unsets the "TLogReadFiles" attribute
         */
        public void unsetTLogReadFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TLOGREADFILES$62);
            }
        }
        
        /**
         * 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$64);
                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$64) != 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$64);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TLOGWRITEFILES$64);
                }
                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$64);
                return target;
            }
        }
        
        /**
         * Unsets the "TLogWriteFiles" attribute
         */
        public void unsetTLogWriteFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TLOGWRITEFILES$64);
            }
        }
        
        /**
         * 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$66);
                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$66) != 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$66);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLEXE$66);
                }
                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$66);
                return target;
            }
        }
        
        /**
         * Unsets the "ToolExe" attribute
         */
        public void unsetToolExe()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TOOLEXE$66);
            }
        }
        
        /**
         * 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$68);
                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$68) != 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$68);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TOOLPATH$68);
                }
                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$68);
                return target;
            }
        }
        
        /**
         * Unsets the "ToolPath" attribute
         */
        public void unsetToolPath()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TOOLPATH$68);
            }
        }
        
        /**
         * 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$70);
                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$70) != 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$70);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDINPUTFILESTOIGNORE$70);
                }
                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$70);
                return target;
            }
        }
        
        /**
         * Unsets the "TrackedInputFilesToIgnore" attribute
         */
        public void unsetTrackedInputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKEDINPUTFILESTOIGNORE$70);
            }
        }
        
        /**
         * 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$72);
                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$72) != 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$72);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKEDOUTPUTFILESTOIGNORE$72);
                }
                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$72);
                return target;
            }
        }
        
        /**
         * Unsets the "TrackedOutputFilesToIgnore" attribute
         */
        public void unsetTrackedOutputFilesToIgnore()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKEDOUTPUTFILESTOIGNORE$72);
            }
        }
        
        /**
         * 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$74);
                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$74) != 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$74);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlAnySimpleType)get_store().add_attribute_user(TRACKERLOGDIRECTORY$74);
                }
                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$74);
                return target;
            }
        }
        
        /**
         * Unsets the "TrackerLogDirectory" attribute
         */
        public void unsetTrackerLogDirectory()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKERLOGDIRECTORY$74);
            }
        }
        
        /**
         * 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$76);
                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$76);
                return target;
            }
        }
        
        /**
         * True if has "TrackFileAccess" attribute
         */
        public boolean isSetTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TRACKFILEACCESS$76) != 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$76);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(TRACKFILEACCESS$76);
                }
                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$76);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(TRACKFILEACCESS$76);
                }
                target.set(trackFileAccess);
            }
        }
        
        /**
         * Unsets the "TrackFileAccess" attribute
         */
        public void unsetTrackFileAccess()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TRACKFILEACCESS$76);
            }
        }
        
        /**
         * Gets the "TreatLibWarningAsErrors" attribute
         */
        public java.lang.String getTreatLibWarningAsErrors()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TREATLIBWARNINGASERRORS$78);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "TreatLibWarningAsErrors" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetTreatLibWarningAsErrors()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(TREATLIBWARNINGASERRORS$78);
                return target;
            }
        }
        
        /**
         * True if has "TreatLibWarningAsErrors" attribute
         */
        public boolean isSetTreatLibWarningAsErrors()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(TREATLIBWARNINGASERRORS$78) != null;
            }
        }
        
        /**
         * Sets the "TreatLibWarningAsErrors" attribute
         */
        public void setTreatLibWarningAsErrors(java.lang.String treatLibWarningAsErrors)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(TREATLIBWARNINGASERRORS$78);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(TREATLIBWARNINGASERRORS$78);
                }
                target.setStringValue(treatLibWarningAsErrors);
            }
        }
        
        /**
         * Sets (as xml) the "TreatLibWarningAsErrors" attribute
         */
        public void xsetTreatLibWarningAsErrors(io.github.isotes.vs.model.Boolean treatLibWarningAsErrors)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(TREATLIBWARNINGASERRORS$78);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(TREATLIBWARNINGASERRORS$78);
                }
                target.set(treatLibWarningAsErrors);
            }
        }
        
        /**
         * Unsets the "TreatLibWarningAsErrors" attribute
         */
        public void unsetTreatLibWarningAsErrors()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(TREATLIBWARNINGASERRORS$78);
            }
        }
        
        /**
         * Gets the "UseUnicodeResponseFiles" attribute
         */
        public java.lang.String getUseUnicodeResponseFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(USEUNICODERESPONSEFILES$80);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "UseUnicodeResponseFiles" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetUseUnicodeResponseFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(USEUNICODERESPONSEFILES$80);
                return target;
            }
        }
        
        /**
         * True if has "UseUnicodeResponseFiles" attribute
         */
        public boolean isSetUseUnicodeResponseFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(USEUNICODERESPONSEFILES$80) != null;
            }
        }
        
        /**
         * Sets the "UseUnicodeResponseFiles" attribute
         */
        public void setUseUnicodeResponseFiles(java.lang.String useUnicodeResponseFiles)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(USEUNICODERESPONSEFILES$80);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(USEUNICODERESPONSEFILES$80);
                }
                target.setStringValue(useUnicodeResponseFiles);
            }
        }
        
        /**
         * Sets (as xml) the "UseUnicodeResponseFiles" attribute
         */
        public void xsetUseUnicodeResponseFiles(io.github.isotes.vs.model.Boolean useUnicodeResponseFiles)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(USEUNICODERESPONSEFILES$80);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(USEUNICODERESPONSEFILES$80);
                }
                target.set(useUnicodeResponseFiles);
            }
        }
        
        /**
         * Unsets the "UseUnicodeResponseFiles" attribute
         */
        public void unsetUseUnicodeResponseFiles()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(USEUNICODERESPONSEFILES$80);
            }
        }
        
        /**
         * Gets the "Verbose" attribute
         */
        public java.lang.String getVerbose()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VERBOSE$82);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "Verbose" attribute
         */
        public io.github.isotes.vs.model.Boolean xgetVerbose()
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(VERBOSE$82);
                return target;
            }
        }
        
        /**
         * True if has "Verbose" attribute
         */
        public boolean isSetVerbose()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(VERBOSE$82) != null;
            }
        }
        
        /**
         * Sets the "Verbose" attribute
         */
        public void setVerbose(java.lang.String verbose)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VERBOSE$82);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(VERBOSE$82);
                }
                target.setStringValue(verbose);
            }
        }
        
        /**
         * Sets (as xml) the "Verbose" attribute
         */
        public void xsetVerbose(io.github.isotes.vs.model.Boolean verbose)
        {
            synchronized (monitor())
            {
                check_orphaned();
                io.github.isotes.vs.model.Boolean target = null;
                target = (io.github.isotes.vs.model.Boolean)get_store().find_attribute_user(VERBOSE$82);
                if (target == null)
                {
                    target = (io.github.isotes.vs.model.Boolean)get_store().add_attribute_user(VERBOSE$82);
                }
                target.set(verbose);
            }
        }
        
        /**
         * Unsets the "Verbose" attribute
         */
        public void unsetVerbose()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(VERBOSE$82);
            }
        }
    }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy