Mt_.hpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/* $Id$
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 */
 
/// @file Mt_.hpp
/// Data storage class.
///
/// This file was generated by application DATATOOL
/// using the following specifications:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/build-system/project_tree_builder/msbuild/msbuild_dataobj.xsd">msbuild_dataobj.xsd</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/build-system/project_tree_builder/msbuild/msbuild_dataobj.def">msbuild_dataobj.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef msbuild__BUILD_SYSTEM_PROJECT_TREE_BUILDER_MSBUILD_MT_BASE_HPP
#define msbuild__BUILD_SYSTEM_PROJECT_TREE_BUILDER_MSBUILD_MT_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
 
// generated includes
#include <string>
#include <build-system/project_tree_builder/msbuild/TaskType.hpp>
 
#ifndef BEGIN_msbuild_SCOPE
#  define BEGIN_msbuild_SCOPE BEGIN_SCOPE(msbuild)
#  define END_msbuild_SCOPE END_SCOPE(msbuild)
#endif
BEGIN_msbuild_SCOPE // namespace msbuild::
 
 
// generated classes
 
 
/** @addtogroup dataspec_msbuild_dataobj
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
/// ncbi: removed MIDL 
///
/// CMt_Base --
///
 
class CMt_Base : public NCBI_NS_NCBI::CSerialObject
{
    typedef NCBI_NS_NCBI::CSerialObject Tparent;
public:
    // constructor
    CMt_Base(void);
    // destructor
    virtual ~CMt_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_Attlist --
    ///
    
    class C_Attlist : public NCBI_NS_NCBI::CSerialObject
    {
        typedef NCBI_NS_NCBI::CSerialObject Tparent;
    public:
        // constructor
        C_Attlist(void);
        // destructor
        ~C_Attlist(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        // types
        typedef NCBI_NS_STD::string TAcceptableNonZeroExitCodes;
        typedef NCBI_NS_STD::string TActiveToolSwitchesValues;
        typedef NCBI_NS_STD::string TAdditionalManifestFiles;
        typedef NCBI_NS_STD::string TAdditionalOptions;
        typedef NCBI_NS_STD::string TAssemblyIdentity;
        typedef NCBI_NS_STD::string TComponentFileName;
        typedef NCBI_NS_STD::string TEmbedManifest;
        typedef NCBI_NS_STD::string TEnvironmentVariables;
        typedef NCBI_NS_STD::string TExcludedInputPaths;
        typedef NCBI_NS_STD::string TGenerateCatalogFiles;
        typedef NCBI_NS_STD::string TGenerateCategoryTags;
        typedef NCBI_NS_STD::string TInputResourceManifests;
        typedef NCBI_NS_STD::string TLogStandardErrorAsError;
        typedef NCBI_NS_STD::string TManifestFromManagedAssembly;
        typedef NCBI_NS_STD::string TMinimalRebuildFromTracking;
        typedef NCBI_NS_STD::string TOutputManifestFile;
        typedef NCBI_NS_STD::string TOutputResourceManifests;
        typedef NCBI_NS_STD::string TPathOverride;
        typedef NCBI_NS_STD::string TRegistrarScriptFile;
        typedef NCBI_NS_STD::string TReplacementsFile;
        typedef NCBI_NS_STD::string TResourceOutputFileName;
        typedef NCBI_NS_STD::string TSkippedExecution;
        typedef NCBI_NS_STD::string TSources;
        typedef NCBI_NS_STD::string TSourcesCompiled;
        typedef NCBI_NS_STD::string TStandardErrorImportance;
        typedef NCBI_NS_STD::string TStandardOutputImportance;
        typedef NCBI_NS_STD::string TSuppressDependencyElement;
        typedef NCBI_NS_STD::string TSuppressStartupBanner;
        typedef NCBI_NS_STD::string TTimeout;
        typedef NCBI_NS_STD::string TTLogReadFiles;
        typedef NCBI_NS_STD::string TTLogWriteFiles;
        typedef NCBI_NS_STD::string TToolExe;
        typedef NCBI_NS_STD::string TToolPath;
        typedef NCBI_NS_STD::string TTrackedInputFilesToIgnore;
        typedef NCBI_NS_STD::string TTrackedOutputFilesToIgnore;
        typedef NCBI_NS_STD::string TTrackerLogDirectory;
        typedef NCBI_NS_STD::string TTrackFileAccess;
        typedef NCBI_NS_STD::string TTypeLibraryFile;
        typedef NCBI_NS_STD::string TUpdateFileHashes;
        typedef NCBI_NS_STD::string TUpdateFileHashesSearchPath;
        typedef NCBI_NS_STD::string TVerboseOutput;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_AcceptableNonZeroExitCodes,
            e_ActiveToolSwitchesValues,
            e_AdditionalManifestFiles,
            e_AdditionalOptions,
            e_AssemblyIdentity,
            e_ComponentFileName,
            e_EmbedManifest,
            e_EnvironmentVariables,
            e_ExcludedInputPaths,
            e_GenerateCatalogFiles,
            e_GenerateCategoryTags,
            e_InputResourceManifests,
            e_LogStandardErrorAsError,
            e_ManifestFromManagedAssembly,
            e_MinimalRebuildFromTracking,
            e_OutputManifestFile,
            e_OutputResourceManifests,
            e_PathOverride,
            e_RegistrarScriptFile,
            e_ReplacementsFile,
            e_ResourceOutputFileName,
            e_SkippedExecution,
            e_Sources,
            e_SourcesCompiled,
            e_StandardErrorImportance,
            e_StandardOutputImportance,
            e_SuppressDependencyElement,
            e_SuppressStartupBanner,
            e_Timeout,
            e_TLogReadFiles,
            e_TLogWriteFiles,
            e_ToolExe,
            e_ToolPath,
            e_TrackedInputFilesToIgnore,
            e_TrackedOutputFilesToIgnore,
            e_TrackerLogDirectory,
            e_TrackFileAccess,
            e_TypeLibraryFile,
            e_UpdateFileHashes,
            e_UpdateFileHashesSearchPath,
            e_VerboseOutput
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 42> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to AcceptableNonZeroExitCodes data member.
        ///
        /// Data member AcceptableNonZeroExitCodes is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TAcceptableNonZeroExitCodes'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAcceptableNonZeroExitCodes(void) const;
    
        /// Check if it is safe to call GetAcceptableNonZeroExitCodes method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAcceptableNonZeroExitCodes(void) const;
    
        /// Reset AcceptableNonZeroExitCodes data member.
        void ResetAcceptableNonZeroExitCodes(void);
    
        /// Get the AcceptableNonZeroExitCodes member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAcceptableNonZeroExitCodes& GetAcceptableNonZeroExitCodes(void) const;
    
        /// Assign a value to AcceptableNonZeroExitCodes data member.
        ///
        /// @param value
        ///   Value to assign
        void SetAcceptableNonZeroExitCodes(const TAcceptableNonZeroExitCodes& value);
        void SetAcceptableNonZeroExitCodes(TAcceptableNonZeroExitCodes&& value);
    
        /// Assign a value to AcceptableNonZeroExitCodes data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAcceptableNonZeroExitCodes& SetAcceptableNonZeroExitCodes(void);
    
        /// Check if a value has been assigned to ActiveToolSwitchesValues data member.
        ///
        /// Data member ActiveToolSwitchesValues is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TActiveToolSwitchesValues'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetActiveToolSwitchesValues(void) const;
    
        /// Check if it is safe to call GetActiveToolSwitchesValues method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetActiveToolSwitchesValues(void) const;
    
        /// Reset ActiveToolSwitchesValues data member.
        void ResetActiveToolSwitchesValues(void);
    
        /// Get the ActiveToolSwitchesValues member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TActiveToolSwitchesValues& GetActiveToolSwitchesValues(void) const;
    
        /// Assign a value to ActiveToolSwitchesValues data member.
        ///
        /// @param value
        ///   Value to assign
        void SetActiveToolSwitchesValues(const TActiveToolSwitchesValues& value);
        void SetActiveToolSwitchesValues(TActiveToolSwitchesValues&& value);
    
        /// Assign a value to ActiveToolSwitchesValues data member.
        ///
        /// @return
        ///   Reference to the data value.
        TActiveToolSwitchesValues& SetActiveToolSwitchesValues(void);
    
        /// Check if a value has been assigned to AdditionalManifestFiles data member.
        ///
        /// Data member AdditionalManifestFiles is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TAdditionalManifestFiles'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAdditionalManifestFiles(void) const;
    
        /// Check if it is safe to call GetAdditionalManifestFiles method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAdditionalManifestFiles(void) const;
    
        /// Reset AdditionalManifestFiles data member.
        void ResetAdditionalManifestFiles(void);
    
        /// Get the AdditionalManifestFiles member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAdditionalManifestFiles& GetAdditionalManifestFiles(void) const;
    
        /// Assign a value to AdditionalManifestFiles data member.
        ///
        /// @param value
        ///   Value to assign
        void SetAdditionalManifestFiles(const TAdditionalManifestFiles& value);
        void SetAdditionalManifestFiles(TAdditionalManifestFiles&& value);
    
        /// Assign a value to AdditionalManifestFiles data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAdditionalManifestFiles& SetAdditionalManifestFiles(void);
    
        /// Check if a value has been assigned to AdditionalOptions data member.
        ///
        /// Data member AdditionalOptions is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TAdditionalOptions'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAdditionalOptions(void) const;
    
        /// Check if it is safe to call GetAdditionalOptions method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAdditionalOptions(void) const;
    
        /// Reset AdditionalOptions data member.
        void ResetAdditionalOptions(void);
    
        /// Get the AdditionalOptions member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAdditionalOptions& GetAdditionalOptions(void) const;
    
        /// Assign a value to AdditionalOptions data member.
        ///
        /// @param value
        ///   Value to assign
        void SetAdditionalOptions(const TAdditionalOptions& value);
        void SetAdditionalOptions(TAdditionalOptions&& value);
    
        /// Assign a value to AdditionalOptions data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAdditionalOptions& SetAdditionalOptions(void);
    
        /// Check if a value has been assigned to AssemblyIdentity data member.
        ///
        /// Data member AssemblyIdentity is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TAssemblyIdentity'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAssemblyIdentity(void) const;
    
        /// Check if it is safe to call GetAssemblyIdentity method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAssemblyIdentity(void) const;
    
        /// Reset AssemblyIdentity data member.
        void ResetAssemblyIdentity(void);
    
        /// Get the AssemblyIdentity member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAssemblyIdentity& GetAssemblyIdentity(void) const;
    
        /// Assign a value to AssemblyIdentity data member.
        ///
        /// @param value
        ///   Value to assign
        void SetAssemblyIdentity(const TAssemblyIdentity& value);
        void SetAssemblyIdentity(TAssemblyIdentity&& value);
    
        /// Assign a value to AssemblyIdentity data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAssemblyIdentity& SetAssemblyIdentity(void);
    
        /// Check if a value has been assigned to ComponentFileName data member.
        ///
        /// Data member ComponentFileName is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TComponentFileName'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetComponentFileName(void) const;
    
        /// Check if it is safe to call GetComponentFileName method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetComponentFileName(void) const;
    
        /// Reset ComponentFileName data member.
        void ResetComponentFileName(void);
    
        /// Get the ComponentFileName member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TComponentFileName& GetComponentFileName(void) const;
    
        /// Assign a value to ComponentFileName data member.
        ///
        /// @param value
        ///   Value to assign
        void SetComponentFileName(const TComponentFileName& value);
        void SetComponentFileName(TComponentFileName&& value);
    
        /// Assign a value to ComponentFileName data member.
        ///
        /// @return
        ///   Reference to the data value.
        TComponentFileName& SetComponentFileName(void);
    
        /// Check if a value has been assigned to EmbedManifest data member.
        ///
        /// Data member EmbedManifest is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TEmbedManifest'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetEmbedManifest(void) const;
    
        /// Check if it is safe to call GetEmbedManifest method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetEmbedManifest(void) const;
    
        /// Reset EmbedManifest data member.
        void ResetEmbedManifest(void);
    
        /// Get the EmbedManifest member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TEmbedManifest& GetEmbedManifest(void) const;
    
        /// Assign a value to EmbedManifest data member.
        ///
        /// @param value
        ///   Value to assign
        void SetEmbedManifest(const TEmbedManifest& value);
        void SetEmbedManifest(TEmbedManifest&& value);
    
        /// Assign a value to EmbedManifest data member.
        ///
        /// @return
        ///   Reference to the data value.
        TEmbedManifest& SetEmbedManifest(void);
    
        /// Check if a value has been assigned to EnvironmentVariables data member.
        ///
        /// Data member EnvironmentVariables is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TEnvironmentVariables'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetEnvironmentVariables(void) const;
    
        /// Check if it is safe to call GetEnvironmentVariables method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetEnvironmentVariables(void) const;
    
        /// Reset EnvironmentVariables data member.
        void ResetEnvironmentVariables(void);
    
        /// Get the EnvironmentVariables member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TEnvironmentVariables& GetEnvironmentVariables(void) const;
    
        /// Assign a value to EnvironmentVariables data member.
        ///
        /// @param value
        ///   Value to assign
        void SetEnvironmentVariables(const TEnvironmentVariables& value);
        void SetEnvironmentVariables(TEnvironmentVariables&& value);
    
        /// Assign a value to EnvironmentVariables data member.
        ///
        /// @return
        ///   Reference to the data value.
        TEnvironmentVariables& SetEnvironmentVariables(void);
    
        /// Check if a value has been assigned to ExcludedInputPaths data member.
        ///
        /// Data member ExcludedInputPaths is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TExcludedInputPaths'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetExcludedInputPaths(void) const;
    
        /// Check if it is safe to call GetExcludedInputPaths method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetExcludedInputPaths(void) const;
    
        /// Reset ExcludedInputPaths data member.
        void ResetExcludedInputPaths(void);
    
        /// Get the ExcludedInputPaths member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TExcludedInputPaths& GetExcludedInputPaths(void) const;
    
        /// Assign a value to ExcludedInputPaths data member.
        ///
        /// @param value
        ///   Value to assign
        void SetExcludedInputPaths(const TExcludedInputPaths& value);
        void SetExcludedInputPaths(TExcludedInputPaths&& value);
    
        /// Assign a value to ExcludedInputPaths data member.
        ///
        /// @return
        ///   Reference to the data value.
        TExcludedInputPaths& SetExcludedInputPaths(void);
    
        /// Check if a value has been assigned to GenerateCatalogFiles data member.
        ///
        /// Data member GenerateCatalogFiles is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TGenerateCatalogFiles'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetGenerateCatalogFiles(void) const;
    
        /// Check if it is safe to call GetGenerateCatalogFiles method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetGenerateCatalogFiles(void) const;
    
        /// Reset GenerateCatalogFiles data member.
        void ResetGenerateCatalogFiles(void);
    
        /// Get the GenerateCatalogFiles member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TGenerateCatalogFiles& GetGenerateCatalogFiles(void) const;
    
        /// Assign a value to GenerateCatalogFiles data member.
        ///
        /// @param value
        ///   Value to assign
        void SetGenerateCatalogFiles(const TGenerateCatalogFiles& value);
        void SetGenerateCatalogFiles(TGenerateCatalogFiles&& value);
    
        /// Assign a value to GenerateCatalogFiles data member.
        ///
        /// @return
        ///   Reference to the data value.
        TGenerateCatalogFiles& SetGenerateCatalogFiles(void);
    
        /// Check if a value has been assigned to GenerateCategoryTags data member.
        ///
        /// Data member GenerateCategoryTags is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TGenerateCategoryTags'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetGenerateCategoryTags(void) const;
    
        /// Check if it is safe to call GetGenerateCategoryTags method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetGenerateCategoryTags(void) const;
    
        /// Reset GenerateCategoryTags data member.
        void ResetGenerateCategoryTags(void);
    
        /// Get the GenerateCategoryTags member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TGenerateCategoryTags& GetGenerateCategoryTags(void) const;
    
        /// Assign a value to GenerateCategoryTags data member.
        ///
        /// @param value
        ///   Value to assign
        void SetGenerateCategoryTags(const TGenerateCategoryTags& value);
        void SetGenerateCategoryTags(TGenerateCategoryTags&& value);
    
        /// Assign a value to GenerateCategoryTags data member.
        ///
        /// @return
        ///   Reference to the data value.
        TGenerateCategoryTags& SetGenerateCategoryTags(void);
    
        /// Check if a value has been assigned to InputResourceManifests data member.
        ///
        /// Data member InputResourceManifests is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TInputResourceManifests'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetInputResourceManifests(void) const;
    
        /// Check if it is safe to call GetInputResourceManifests method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetInputResourceManifests(void) const;
    
        /// Reset InputResourceManifests data member.
        void ResetInputResourceManifests(void);
    
        /// Get the InputResourceManifests member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TInputResourceManifests& GetInputResourceManifests(void) const;
    
        /// Assign a value to InputResourceManifests data member.
        ///
        /// @param value
        ///   Value to assign
        void SetInputResourceManifests(const TInputResourceManifests& value);
        void SetInputResourceManifests(TInputResourceManifests&& value);
    
        /// Assign a value to InputResourceManifests data member.
        ///
        /// @return
        ///   Reference to the data value.
        TInputResourceManifests& SetInputResourceManifests(void);
    
        /// Check if a value has been assigned to LogStandardErrorAsError data member.
        ///
        /// Data member LogStandardErrorAsError is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TLogStandardErrorAsError'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetLogStandardErrorAsError(void) const;
    
        /// Check if it is safe to call GetLogStandardErrorAsError method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetLogStandardErrorAsError(void) const;
    
        /// Reset LogStandardErrorAsError data member.
        void ResetLogStandardErrorAsError(void);
    
        /// Get the LogStandardErrorAsError member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TLogStandardErrorAsError& GetLogStandardErrorAsError(void) const;
    
        /// Assign a value to LogStandardErrorAsError data member.
        ///
        /// @param value
        ///   Value to assign
        void SetLogStandardErrorAsError(const TLogStandardErrorAsError& value);
        void SetLogStandardErrorAsError(TLogStandardErrorAsError&& value);
    
        /// Assign a value to LogStandardErrorAsError data member.
        ///
        /// @return
        ///   Reference to the data value.
        TLogStandardErrorAsError& SetLogStandardErrorAsError(void);
    
        /// Check if a value has been assigned to ManifestFromManagedAssembly data member.
        ///
        /// Data member ManifestFromManagedAssembly is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TManifestFromManagedAssembly'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetManifestFromManagedAssembly(void) const;
    
        /// Check if it is safe to call GetManifestFromManagedAssembly method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetManifestFromManagedAssembly(void) const;
    
        /// Reset ManifestFromManagedAssembly data member.
        void ResetManifestFromManagedAssembly(void);
    
        /// Get the ManifestFromManagedAssembly member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TManifestFromManagedAssembly& GetManifestFromManagedAssembly(void) const;
    
        /// Assign a value to ManifestFromManagedAssembly data member.
        ///
        /// @param value
        ///   Value to assign
        void SetManifestFromManagedAssembly(const TManifestFromManagedAssembly& value);
        void SetManifestFromManagedAssembly(TManifestFromManagedAssembly&& value);
    
        /// Assign a value to ManifestFromManagedAssembly data member.
        ///
        /// @return
        ///   Reference to the data value.
        TManifestFromManagedAssembly& SetManifestFromManagedAssembly(void);
    
        /// Check if a value has been assigned to MinimalRebuildFromTracking data member.
        ///
        /// Data member MinimalRebuildFromTracking is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TMinimalRebuildFromTracking'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetMinimalRebuildFromTracking(void) const;
    
        /// Check if it is safe to call GetMinimalRebuildFromTracking method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetMinimalRebuildFromTracking(void) const;
    
        /// Reset MinimalRebuildFromTracking data member.
        void ResetMinimalRebuildFromTracking(void);
    
        /// Get the MinimalRebuildFromTracking member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TMinimalRebuildFromTracking& GetMinimalRebuildFromTracking(void) const;
    
        /// Assign a value to MinimalRebuildFromTracking data member.
        ///
        /// @param value
        ///   Value to assign
        void SetMinimalRebuildFromTracking(const TMinimalRebuildFromTracking& value);
        void SetMinimalRebuildFromTracking(TMinimalRebuildFromTracking&& value);
    
        /// Assign a value to MinimalRebuildFromTracking data member.
        ///
        /// @return
        ///   Reference to the data value.
        TMinimalRebuildFromTracking& SetMinimalRebuildFromTracking(void);
    
        /// Check if a value has been assigned to OutputManifestFile data member.
        ///
        /// Data member OutputManifestFile is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TOutputManifestFile'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetOutputManifestFile(void) const;
    
        /// Check if it is safe to call GetOutputManifestFile method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetOutputManifestFile(void) const;
    
        /// Reset OutputManifestFile data member.
        void ResetOutputManifestFile(void);
    
        /// Get the OutputManifestFile member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TOutputManifestFile& GetOutputManifestFile(void) const;
    
        /// Assign a value to OutputManifestFile data member.
        ///
        /// @param value
        ///   Value to assign
        void SetOutputManifestFile(const TOutputManifestFile& value);
        void SetOutputManifestFile(TOutputManifestFile&& value);
    
        /// Assign a value to OutputManifestFile data member.
        ///
        /// @return
        ///   Reference to the data value.
        TOutputManifestFile& SetOutputManifestFile(void);
    
        /// Check if a value has been assigned to OutputResourceManifests data member.
        ///
        /// Data member OutputResourceManifests is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TOutputResourceManifests'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetOutputResourceManifests(void) const;
    
        /// Check if it is safe to call GetOutputResourceManifests method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetOutputResourceManifests(void) const;
    
        /// Reset OutputResourceManifests data member.
        void ResetOutputResourceManifests(void);
    
        /// Get the OutputResourceManifests member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TOutputResourceManifests& GetOutputResourceManifests(void) const;
    
        /// Assign a value to OutputResourceManifests data member.
        ///
        /// @param value
        ///   Value to assign
        void SetOutputResourceManifests(const TOutputResourceManifests& value);
        void SetOutputResourceManifests(TOutputResourceManifests&& value);
    
        /// Assign a value to OutputResourceManifests data member.
        ///
        /// @return
        ///   Reference to the data value.
        TOutputResourceManifests& SetOutputResourceManifests(void);
    
        /// Check if a value has been assigned to PathOverride data member.
        ///
        /// Data member PathOverride is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TPathOverride'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetPathOverride(void) const;
    
        /// Check if it is safe to call GetPathOverride method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetPathOverride(void) const;
    
        /// Reset PathOverride data member.
        void ResetPathOverride(void);
    
        /// Get the PathOverride member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TPathOverride& GetPathOverride(void) const;
    
        /// Assign a value to PathOverride data member.
        ///
        /// @param value
        ///   Value to assign
        void SetPathOverride(const TPathOverride& value);
        void SetPathOverride(TPathOverride&& value);
    
        /// Assign a value to PathOverride data member.
        ///
        /// @return
        ///   Reference to the data value.
        TPathOverride& SetPathOverride(void);
    
        /// Check if a value has been assigned to RegistrarScriptFile data member.
        ///
        /// Data member RegistrarScriptFile is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TRegistrarScriptFile'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetRegistrarScriptFile(void) const;
    
        /// Check if it is safe to call GetRegistrarScriptFile method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetRegistrarScriptFile(void) const;
    
        /// Reset RegistrarScriptFile data member.
        void ResetRegistrarScriptFile(void);
    
        /// Get the RegistrarScriptFile member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TRegistrarScriptFile& GetRegistrarScriptFile(void) const;
    
        /// Assign a value to RegistrarScriptFile data member.
        ///
        /// @param value
        ///   Value to assign
        void SetRegistrarScriptFile(const TRegistrarScriptFile& value);
        void SetRegistrarScriptFile(TRegistrarScriptFile&& value);
    
        /// Assign a value to RegistrarScriptFile data member.
        ///
        /// @return
        ///   Reference to the data value.
        TRegistrarScriptFile& SetRegistrarScriptFile(void);
    
        /// Check if a value has been assigned to ReplacementsFile data member.
        ///
        /// Data member ReplacementsFile is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TReplacementsFile'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetReplacementsFile(void) const;
    
        /// Check if it is safe to call GetReplacementsFile method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetReplacementsFile(void) const;
    
        /// Reset ReplacementsFile data member.
        void ResetReplacementsFile(void);
    
        /// Get the ReplacementsFile member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TReplacementsFile& GetReplacementsFile(void) const;
    
        /// Assign a value to ReplacementsFile data member.
        ///
        /// @param value
        ///   Value to assign
        void SetReplacementsFile(const TReplacementsFile& value);
        void SetReplacementsFile(TReplacementsFile&& value);
    
        /// Assign a value to ReplacementsFile data member.
        ///
        /// @return
        ///   Reference to the data value.
        TReplacementsFile& SetReplacementsFile(void);
    
        /// Check if a value has been assigned to ResourceOutputFileName data member.
        ///
        /// Data member ResourceOutputFileName is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TResourceOutputFileName'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetResourceOutputFileName(void) const;
    
        /// Check if it is safe to call GetResourceOutputFileName method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetResourceOutputFileName(void) const;
    
        /// Reset ResourceOutputFileName data member.
        void ResetResourceOutputFileName(void);
    
        /// Get the ResourceOutputFileName member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TResourceOutputFileName& GetResourceOutputFileName(void) const;
    
        /// Assign a value to ResourceOutputFileName data member.
        ///
        /// @param value
        ///   Value to assign
        void SetResourceOutputFileName(const TResourceOutputFileName& value);
        void SetResourceOutputFileName(TResourceOutputFileName&& value);
    
        /// Assign a value to ResourceOutputFileName data member.
        ///
        /// @return
        ///   Reference to the data value.
        TResourceOutputFileName& SetResourceOutputFileName(void);
    
        /// Check if a value has been assigned to SkippedExecution data member.
        ///
        /// Data member SkippedExecution is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TSkippedExecution'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSkippedExecution(void) const;
    
        /// Check if it is safe to call GetSkippedExecution method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSkippedExecution(void) const;
    
        /// Reset SkippedExecution data member.
        void ResetSkippedExecution(void);
    
        /// Get the SkippedExecution member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TSkippedExecution& GetSkippedExecution(void) const;
    
        /// Assign a value to SkippedExecution data member.
        ///
        /// @param value
        ///   Value to assign
        void SetSkippedExecution(const TSkippedExecution& value);
        void SetSkippedExecution(TSkippedExecution&& value);
    
        /// Assign a value to SkippedExecution data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSkippedExecution& SetSkippedExecution(void);
    
        /// Check if a value has been assigned to Sources data member.
        ///
        /// Data member Sources is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TSources'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSources(void) const;
    
        /// Check if it is safe to call GetSources method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSources(void) const;
    
        /// Reset Sources data member.
        void ResetSources(void);
    
        /// Get the Sources member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TSources& GetSources(void) const;
    
        /// Assign a value to Sources data member.
        ///
        /// @param value
        ///   Value to assign
        void SetSources(const TSources& value);
        void SetSources(TSources&& value);
    
        /// Assign a value to Sources data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSources& SetSources(void);
    
        /// Check if a value has been assigned to SourcesCompiled data member.
        ///
        /// Data member SourcesCompiled is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TSourcesCompiled'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSourcesCompiled(void) const;
    
        /// Check if it is safe to call GetSourcesCompiled method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSourcesCompiled(void) const;
    
        /// Reset SourcesCompiled data member.
        void ResetSourcesCompiled(void);
    
        /// Get the SourcesCompiled member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TSourcesCompiled& GetSourcesCompiled(void) const;
    
        /// Assign a value to SourcesCompiled data member.
        ///
        /// @param value
        ///   Value to assign
        void SetSourcesCompiled(const TSourcesCompiled& value);
        void SetSourcesCompiled(TSourcesCompiled&& value);
    
        /// Assign a value to SourcesCompiled data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSourcesCompiled& SetSourcesCompiled(void);
    
        /// Check if a value has been assigned to StandardErrorImportance data member.
        ///
        /// Data member StandardErrorImportance is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TStandardErrorImportance'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetStandardErrorImportance(void) const;
    
        /// Check if it is safe to call GetStandardErrorImportance method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetStandardErrorImportance(void) const;
    
        /// Reset StandardErrorImportance data member.
        void ResetStandardErrorImportance(void);
    
        /// Get the StandardErrorImportance member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TStandardErrorImportance& GetStandardErrorImportance(void) const;
    
        /// Assign a value to StandardErrorImportance data member.
        ///
        /// @param value
        ///   Value to assign
        void SetStandardErrorImportance(const TStandardErrorImportance& value);
        void SetStandardErrorImportance(TStandardErrorImportance&& value);
    
        /// Assign a value to StandardErrorImportance data member.
        ///
        /// @return
        ///   Reference to the data value.
        TStandardErrorImportance& SetStandardErrorImportance(void);
    
        /// Check if a value has been assigned to StandardOutputImportance data member.
        ///
        /// Data member StandardOutputImportance is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TStandardOutputImportance'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetStandardOutputImportance(void) const;
    
        /// Check if it is safe to call GetStandardOutputImportance method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetStandardOutputImportance(void) const;
    
        /// Reset StandardOutputImportance data member.
        void ResetStandardOutputImportance(void);
    
        /// Get the StandardOutputImportance member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TStandardOutputImportance& GetStandardOutputImportance(void) const;
    
        /// Assign a value to StandardOutputImportance data member.
        ///
        /// @param value
        ///   Value to assign
        void SetStandardOutputImportance(const TStandardOutputImportance& value);
        void SetStandardOutputImportance(TStandardOutputImportance&& value);
    
        /// Assign a value to StandardOutputImportance data member.
        ///
        /// @return
        ///   Reference to the data value.
        TStandardOutputImportance& SetStandardOutputImportance(void);
    
        /// Check if a value has been assigned to SuppressDependencyElement data member.
        ///
        /// Data member SuppressDependencyElement is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TSuppressDependencyElement'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSuppressDependencyElement(void) const;
    
        /// Check if it is safe to call GetSuppressDependencyElement method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSuppressDependencyElement(void) const;
    
        /// Reset SuppressDependencyElement data member.
        void ResetSuppressDependencyElement(void);
    
        /// Get the SuppressDependencyElement member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TSuppressDependencyElement& GetSuppressDependencyElement(void) const;
    
        /// Assign a value to SuppressDependencyElement data member.
        ///
        /// @param value
        ///   Value to assign
        void SetSuppressDependencyElement(const TSuppressDependencyElement& value);
        void SetSuppressDependencyElement(TSuppressDependencyElement&& value);
    
        /// Assign a value to SuppressDependencyElement data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSuppressDependencyElement& SetSuppressDependencyElement(void);
    
        /// Check if a value has been assigned to SuppressStartupBanner data member.
        ///
        /// Data member SuppressStartupBanner is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TSuppressStartupBanner'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSuppressStartupBanner(void) const;
    
        /// Check if it is safe to call GetSuppressStartupBanner method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSuppressStartupBanner(void) const;
    
        /// Reset SuppressStartupBanner data member.
        void ResetSuppressStartupBanner(void);
    
        /// Get the SuppressStartupBanner member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TSuppressStartupBanner& GetSuppressStartupBanner(void) const;
    
        /// Assign a value to SuppressStartupBanner data member.
        ///
        /// @param value
        ///   Value to assign
        void SetSuppressStartupBanner(const TSuppressStartupBanner& value);
        void SetSuppressStartupBanner(TSuppressStartupBanner&& value);
    
        /// Assign a value to SuppressStartupBanner data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSuppressStartupBanner& SetSuppressStartupBanner(void);
    
        /// Check if a value has been assigned to Timeout data member.
        ///
        /// Data member Timeout is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TTimeout'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTimeout(void) const;
    
        /// Check if it is safe to call GetTimeout method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTimeout(void) const;
    
        /// Reset Timeout data member.
        void ResetTimeout(void);
    
        /// Get the Timeout member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTimeout& GetTimeout(void) const;
    
        /// Assign a value to Timeout data member.
        ///
        /// @param value
        ///   Value to assign
        void SetTimeout(const TTimeout& value);
        void SetTimeout(TTimeout&& value);
    
        /// Assign a value to Timeout data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTimeout& SetTimeout(void);
    
        /// Check if a value has been assigned to TLogReadFiles data member.
        ///
        /// Data member TLogReadFiles is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TTLogReadFiles'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTLogReadFiles(void) const;
    
        /// Check if it is safe to call GetTLogReadFiles method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTLogReadFiles(void) const;
    
        /// Reset TLogReadFiles data member.
        void ResetTLogReadFiles(void);
    
        /// Get the TLogReadFiles member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTLogReadFiles& GetTLogReadFiles(void) const;
    
        /// Assign a value to TLogReadFiles data member.
        ///
        /// @param value
        ///   Value to assign
        void SetTLogReadFiles(const TTLogReadFiles& value);
        void SetTLogReadFiles(TTLogReadFiles&& value);
    
        /// Assign a value to TLogReadFiles data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTLogReadFiles& SetTLogReadFiles(void);
    
        /// Check if a value has been assigned to TLogWriteFiles data member.
        ///
        /// Data member TLogWriteFiles is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TTLogWriteFiles'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTLogWriteFiles(void) const;
    
        /// Check if it is safe to call GetTLogWriteFiles method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTLogWriteFiles(void) const;
    
        /// Reset TLogWriteFiles data member.
        void ResetTLogWriteFiles(void);
    
        /// Get the TLogWriteFiles member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTLogWriteFiles& GetTLogWriteFiles(void) const;
    
        /// Assign a value to TLogWriteFiles data member.
        ///
        /// @param value
        ///   Value to assign
        void SetTLogWriteFiles(const TTLogWriteFiles& value);
        void SetTLogWriteFiles(TTLogWriteFiles&& value);
    
        /// Assign a value to TLogWriteFiles data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTLogWriteFiles& SetTLogWriteFiles(void);
    
        /// Check if a value has been assigned to ToolExe data member.
        ///
        /// Data member ToolExe is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TToolExe'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetToolExe(void) const;
    
        /// Check if it is safe to call GetToolExe method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetToolExe(void) const;
    
        /// Reset ToolExe data member.
        void ResetToolExe(void);
    
        /// Get the ToolExe member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TToolExe& GetToolExe(void) const;
    
        /// Assign a value to ToolExe data member.
        ///
        /// @param value
        ///   Value to assign
        void SetToolExe(const TToolExe& value);
        void SetToolExe(TToolExe&& value);
    
        /// Assign a value to ToolExe data member.
        ///
        /// @return
        ///   Reference to the data value.
        TToolExe& SetToolExe(void);
    
        /// Check if a value has been assigned to ToolPath data member.
        ///
        /// Data member ToolPath is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TToolPath'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetToolPath(void) const;
    
        /// Check if it is safe to call GetToolPath method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetToolPath(void) const;
    
        /// Reset ToolPath data member.
        void ResetToolPath(void);
    
        /// Get the ToolPath member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TToolPath& GetToolPath(void) const;
    
        /// Assign a value to ToolPath data member.
        ///
        /// @param value
        ///   Value to assign
        void SetToolPath(const TToolPath& value);
        void SetToolPath(TToolPath&& value);
    
        /// Assign a value to ToolPath data member.
        ///
        /// @return
        ///   Reference to the data value.
        TToolPath& SetToolPath(void);
    
        /// Check if a value has been assigned to TrackedInputFilesToIgnore data member.
        ///
        /// Data member TrackedInputFilesToIgnore is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TTrackedInputFilesToIgnore'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTrackedInputFilesToIgnore(void) const;
    
        /// Check if it is safe to call GetTrackedInputFilesToIgnore method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTrackedInputFilesToIgnore(void) const;
    
        /// Reset TrackedInputFilesToIgnore data member.
        void ResetTrackedInputFilesToIgnore(void);
    
        /// Get the TrackedInputFilesToIgnore member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTrackedInputFilesToIgnore& GetTrackedInputFilesToIgnore(void) const;
    
        /// Assign a value to TrackedInputFilesToIgnore data member.
        ///
        /// @param value
        ///   Value to assign
        void SetTrackedInputFilesToIgnore(const TTrackedInputFilesToIgnore& value);
        void SetTrackedInputFilesToIgnore(TTrackedInputFilesToIgnore&& value);
    
        /// Assign a value to TrackedInputFilesToIgnore data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTrackedInputFilesToIgnore& SetTrackedInputFilesToIgnore(void);
    
        /// Check if a value has been assigned to TrackedOutputFilesToIgnore data member.
        ///
        /// Data member TrackedOutputFilesToIgnore is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TTrackedOutputFilesToIgnore'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTrackedOutputFilesToIgnore(void) const;
    
        /// Check if it is safe to call GetTrackedOutputFilesToIgnore method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTrackedOutputFilesToIgnore(void) const;
    
        /// Reset TrackedOutputFilesToIgnore data member.
        void ResetTrackedOutputFilesToIgnore(void);
    
        /// Get the TrackedOutputFilesToIgnore member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTrackedOutputFilesToIgnore& GetTrackedOutputFilesToIgnore(void) const;
    
        /// Assign a value to TrackedOutputFilesToIgnore data member.
        ///
        /// @param value
        ///   Value to assign
        void SetTrackedOutputFilesToIgnore(const TTrackedOutputFilesToIgnore& value);
        void SetTrackedOutputFilesToIgnore(TTrackedOutputFilesToIgnore&& value);
    
        /// Assign a value to TrackedOutputFilesToIgnore data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTrackedOutputFilesToIgnore& SetTrackedOutputFilesToIgnore(void);
    
        /// Check if a value has been assigned to TrackerLogDirectory data member.
        ///
        /// Data member TrackerLogDirectory is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TTrackerLogDirectory'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTrackerLogDirectory(void) const;
    
        /// Check if it is safe to call GetTrackerLogDirectory method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTrackerLogDirectory(void) const;
    
        /// Reset TrackerLogDirectory data member.
        void ResetTrackerLogDirectory(void);
    
        /// Get the TrackerLogDirectory member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTrackerLogDirectory& GetTrackerLogDirectory(void) const;
    
        /// Assign a value to TrackerLogDirectory data member.
        ///
        /// @param value
        ///   Value to assign
        void SetTrackerLogDirectory(const TTrackerLogDirectory& value);
        void SetTrackerLogDirectory(TTrackerLogDirectory&& value);
    
        /// Assign a value to TrackerLogDirectory data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTrackerLogDirectory& SetTrackerLogDirectory(void);
    
        /// Check if a value has been assigned to TrackFileAccess data member.
        ///
        /// Data member TrackFileAccess is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TTrackFileAccess'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTrackFileAccess(void) const;
    
        /// Check if it is safe to call GetTrackFileAccess method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTrackFileAccess(void) const;
    
        /// Reset TrackFileAccess data member.
        void ResetTrackFileAccess(void);
    
        /// Get the TrackFileAccess member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTrackFileAccess& GetTrackFileAccess(void) const;
    
        /// Assign a value to TrackFileAccess data member.
        ///
        /// @param value
        ///   Value to assign
        void SetTrackFileAccess(const TTrackFileAccess& value);
        void SetTrackFileAccess(TTrackFileAccess&& value);
    
        /// Assign a value to TrackFileAccess data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTrackFileAccess& SetTrackFileAccess(void);
    
        /// Check if a value has been assigned to TypeLibraryFile data member.
        ///
        /// Data member TypeLibraryFile is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TTypeLibraryFile'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTypeLibraryFile(void) const;
    
        /// Check if it is safe to call GetTypeLibraryFile method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTypeLibraryFile(void) const;
    
        /// Reset TypeLibraryFile data member.
        void ResetTypeLibraryFile(void);
    
        /// Get the TypeLibraryFile member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTypeLibraryFile& GetTypeLibraryFile(void) const;
    
        /// Assign a value to TypeLibraryFile data member.
        ///
        /// @param value
        ///   Value to assign
        void SetTypeLibraryFile(const TTypeLibraryFile& value);
        void SetTypeLibraryFile(TTypeLibraryFile&& value);
    
        /// Assign a value to TypeLibraryFile data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTypeLibraryFile& SetTypeLibraryFile(void);
    
        /// Check if a value has been assigned to UpdateFileHashes data member.
        ///
        /// Data member UpdateFileHashes is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TUpdateFileHashes'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetUpdateFileHashes(void) const;
    
        /// Check if it is safe to call GetUpdateFileHashes method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetUpdateFileHashes(void) const;
    
        /// Reset UpdateFileHashes data member.
        void ResetUpdateFileHashes(void);
    
        /// Get the UpdateFileHashes member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TUpdateFileHashes& GetUpdateFileHashes(void) const;
    
        /// Assign a value to UpdateFileHashes data member.
        ///
        /// @param value
        ///   Value to assign
        void SetUpdateFileHashes(const TUpdateFileHashes& value);
        void SetUpdateFileHashes(TUpdateFileHashes&& value);
    
        /// Assign a value to UpdateFileHashes data member.
        ///
        /// @return
        ///   Reference to the data value.
        TUpdateFileHashes& SetUpdateFileHashes(void);
    
        /// Check if a value has been assigned to UpdateFileHashesSearchPath data member.
        ///
        /// Data member UpdateFileHashesSearchPath is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TUpdateFileHashesSearchPath'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetUpdateFileHashesSearchPath(void) const;
    
        /// Check if it is safe to call GetUpdateFileHashesSearchPath method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetUpdateFileHashesSearchPath(void) const;
    
        /// Reset UpdateFileHashesSearchPath data member.
        void ResetUpdateFileHashesSearchPath(void);
    
        /// Get the UpdateFileHashesSearchPath member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TUpdateFileHashesSearchPath& GetUpdateFileHashesSearchPath(void) const;
    
        /// Assign a value to UpdateFileHashesSearchPath data member.
        ///
        /// @param value
        ///   Value to assign
        void SetUpdateFileHashesSearchPath(const TUpdateFileHashesSearchPath& value);
        void SetUpdateFileHashesSearchPath(TUpdateFileHashesSearchPath&& value);
    
        /// Assign a value to UpdateFileHashesSearchPath data member.
        ///
        /// @return
        ///   Reference to the data value.
        TUpdateFileHashesSearchPath& SetUpdateFileHashesSearchPath(void);
    
        /// Check if a value has been assigned to VerboseOutput data member.
        ///
        /// Data member VerboseOutput is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TVerboseOutput'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetVerboseOutput(void) const;
    
        /// Check if it is safe to call GetVerboseOutput method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetVerboseOutput(void) const;
    
        /// Reset VerboseOutput data member.
        void ResetVerboseOutput(void);
    
        /// Get the VerboseOutput member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TVerboseOutput& GetVerboseOutput(void) const;
    
        /// Assign a value to VerboseOutput data member.
        ///
        /// @param value
        ///   Value to assign
        void SetVerboseOutput(const TVerboseOutput& value);
        void SetVerboseOutput(TVerboseOutput&& value);
    
        /// Assign a value to VerboseOutput data member.
        ///
        /// @return
        ///   Reference to the data value.
        TVerboseOutput& SetVerboseOutput(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_Attlist(const C_Attlist&);
        C_Attlist& operator=(const C_Attlist&);
    
        // data
        Uint4 m_set_State[3];
        NCBI_NS_STD::string m_AcceptableNonZeroExitCodes;
        NCBI_NS_STD::string m_ActiveToolSwitchesValues;
        NCBI_NS_STD::string m_AdditionalManifestFiles;
        NCBI_NS_STD::string m_AdditionalOptions;
        NCBI_NS_STD::string m_AssemblyIdentity;
        NCBI_NS_STD::string m_ComponentFileName;
        NCBI_NS_STD::string m_EmbedManifest;
        NCBI_NS_STD::string m_EnvironmentVariables;
        NCBI_NS_STD::string m_ExcludedInputPaths;
        NCBI_NS_STD::string m_GenerateCatalogFiles;
        NCBI_NS_STD::string m_GenerateCategoryTags;
        NCBI_NS_STD::string m_InputResourceManifests;
        NCBI_NS_STD::string m_LogStandardErrorAsError;
        NCBI_NS_STD::string m_ManifestFromManagedAssembly;
        NCBI_NS_STD::string m_MinimalRebuildFromTracking;
        NCBI_NS_STD::string m_OutputManifestFile;
        NCBI_NS_STD::string m_OutputResourceManifests;
        NCBI_NS_STD::string m_PathOverride;
        NCBI_NS_STD::string m_RegistrarScriptFile;
        NCBI_NS_STD::string m_ReplacementsFile;
        NCBI_NS_STD::string m_ResourceOutputFileName;
        NCBI_NS_STD::string m_SkippedExecution;
        NCBI_NS_STD::string m_Sources;
        NCBI_NS_STD::string m_SourcesCompiled;
        NCBI_NS_STD::string m_StandardErrorImportance;
        NCBI_NS_STD::string m_StandardOutputImportance;
        NCBI_NS_STD::string m_SuppressDependencyElement;
        NCBI_NS_STD::string m_SuppressStartupBanner;
        NCBI_NS_STD::string m_Timeout;
        NCBI_NS_STD::string m_TLogReadFiles;
        NCBI_NS_STD::string m_TLogWriteFiles;
        NCBI_NS_STD::string m_ToolExe;
        NCBI_NS_STD::string m_ToolPath;
        NCBI_NS_STD::string m_TrackedInputFilesToIgnore;
        NCBI_NS_STD::string m_TrackedOutputFilesToIgnore;
        NCBI_NS_STD::string m_TrackerLogDirectory;
        NCBI_NS_STD::string m_TrackFileAccess;
        NCBI_NS_STD::string m_TypeLibraryFile;
        NCBI_NS_STD::string m_UpdateFileHashes;
        NCBI_NS_STD::string m_UpdateFileHashesSearchPath;
        NCBI_NS_STD::string m_VerboseOutput;
    };
    /////////////////////////////////////////////////////////////////////////////
    /// ncbi: removed MIDL 
    ///
    /// C_Mt --
    ///
    
    class C_Mt : public CTaskType
    {
        typedef CTaskType Tparent;
    public:
        C_Mt(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
    
        typedef Tparent::TTaskType TMt;
        bool IsSetMt(void) const {
            return Tparent::IsSetTaskType();
        }
        bool CanGetMt(void) const {
            return Tparent::CanGetTaskType();
        }
        void ResetMt(void) {
            Tparent::ResetTaskType();
        }
        const TMt& GetMt(void) const {
            return Tparent::GetTaskType();
        }
        TMt& SetMt(void) {
            return Tparent::SetTaskType();
        }
    };
    // types
    typedef C_Attlist TAttlist;
    typedef C_Mt TMt;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_Attlist,
        e_Mt
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
 
    // getters
    // setters
 
    /// Check if a value has been assigned to Attlist data member.
    ///
    /// Data member Attlist is mandatory;
    /// its type is defined as 'typedef C_Attlist TAttlist'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetAttlist(void) const;
 
    /// Check if it is safe to call GetAttlist method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetAttlist(void) const;
 
    /// Reset Attlist data member.
    void ResetAttlist(void);
 
    /// Get the Attlist member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TAttlist& GetAttlist(void) const;
 
    /// Assign a value to Attlist data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetAttlist(TAttlist& value);
 
    /// Assign a value to Attlist data member.
    ///
    /// @return
    ///   Reference to the data value.
    TAttlist& SetAttlist(void);
 
    /// Check if a value has been assigned to Mt data member.
    ///
    /// Data member Mt is mandatory;
    /// its type is defined as 'typedef C_Mt TMt'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetMt(void) const;
 
    /// Check if it is safe to call GetMt method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetMt(void) const;
 
    /// Reset Mt data member.
    void ResetMt(void);
 
    /// Get the Mt member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TMt& GetMt(void) const;
 
    /// Assign a value to Mt data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetMt(TMt& value);
 
    /// Assign a value to Mt data member.
    ///
    /// @return
    ///   Reference to the data value.
    TMt& SetMt(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CMt_Base(const CMt_Base&);
    CMt_Base& operator=(const CMt_Base&);
 
    // data
    Uint4 m_set_State[1];
    NCBI_NS_NCBI::CRef< TAttlist > m_Attlist;
    NCBI_NS_NCBI::CRef< TMt > m_Mt;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CMt_Base::C_Attlist::IsSetAcceptableNonZeroExitCodes(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetAcceptableNonZeroExitCodes(void) const
{
    return IsSetAcceptableNonZeroExitCodes();
}
 
inline
const CMt_Base::C_Attlist::TAcceptableNonZeroExitCodes& CMt_Base::C_Attlist::GetAcceptableNonZeroExitCodes(void) const
{
    if (!CanGetAcceptableNonZeroExitCodes()) {
        ThrowUnassigned(0);
    }
    return m_AcceptableNonZeroExitCodes;
}
 
inline
void CMt_Base::C_Attlist::SetAcceptableNonZeroExitCodes(const CMt_Base::C_Attlist::TAcceptableNonZeroExitCodes& value)
{
    m_AcceptableNonZeroExitCodes = value;
    m_set_State[0] |= 0x3;
}
 
inline
void CMt_Base::C_Attlist::SetAcceptableNonZeroExitCodes(CMt_Base::C_Attlist::TAcceptableNonZeroExitCodes&& value)
{
    m_AcceptableNonZeroExitCodes = std::forward<CMt_Base::C_Attlist::TAcceptableNonZeroExitCodes>(value);
    m_set_State[0] |= 0x3;
}
 
inline
CMt_Base::C_Attlist::TAcceptableNonZeroExitCodes& CMt_Base::C_Attlist::SetAcceptableNonZeroExitCodes(void)
{
#ifdef _DEBUG
    if (!IsSetAcceptableNonZeroExitCodes()) {
        m_AcceptableNonZeroExitCodes = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x1;
    return m_AcceptableNonZeroExitCodes;
}
 
inline
bool CMt_Base::C_Attlist::IsSetActiveToolSwitchesValues(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetActiveToolSwitchesValues(void) const
{
    return IsSetActiveToolSwitchesValues();
}
 
inline
const CMt_Base::C_Attlist::TActiveToolSwitchesValues& CMt_Base::C_Attlist::GetActiveToolSwitchesValues(void) const
{
    if (!CanGetActiveToolSwitchesValues()) {
        ThrowUnassigned(1);
    }
    return m_ActiveToolSwitchesValues;
}
 
inline
void CMt_Base::C_Attlist::SetActiveToolSwitchesValues(const CMt_Base::C_Attlist::TActiveToolSwitchesValues& value)
{
    m_ActiveToolSwitchesValues = value;
    m_set_State[0] |= 0xc;
}
 
inline
void CMt_Base::C_Attlist::SetActiveToolSwitchesValues(CMt_Base::C_Attlist::TActiveToolSwitchesValues&& value)
{
    m_ActiveToolSwitchesValues = std::forward<CMt_Base::C_Attlist::TActiveToolSwitchesValues>(value);
    m_set_State[0] |= 0xc;
}
 
inline
CMt_Base::C_Attlist::TActiveToolSwitchesValues& CMt_Base::C_Attlist::SetActiveToolSwitchesValues(void)
{
#ifdef _DEBUG
    if (!IsSetActiveToolSwitchesValues()) {
        m_ActiveToolSwitchesValues = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4;
    return m_ActiveToolSwitchesValues;
}
 
inline
bool CMt_Base::C_Attlist::IsSetAdditionalManifestFiles(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetAdditionalManifestFiles(void) const
{
    return IsSetAdditionalManifestFiles();
}
 
inline
const CMt_Base::C_Attlist::TAdditionalManifestFiles& CMt_Base::C_Attlist::GetAdditionalManifestFiles(void) const
{
    if (!CanGetAdditionalManifestFiles()) {
        ThrowUnassigned(2);
    }
    return m_AdditionalManifestFiles;
}
 
inline
void CMt_Base::C_Attlist::SetAdditionalManifestFiles(const CMt_Base::C_Attlist::TAdditionalManifestFiles& value)
{
    m_AdditionalManifestFiles = value;
    m_set_State[0] |= 0x30;
}
 
inline
void CMt_Base::C_Attlist::SetAdditionalManifestFiles(CMt_Base::C_Attlist::TAdditionalManifestFiles&& value)
{
    m_AdditionalManifestFiles = std::forward<CMt_Base::C_Attlist::TAdditionalManifestFiles>(value);
    m_set_State[0] |= 0x30;
}
 
inline
CMt_Base::C_Attlist::TAdditionalManifestFiles& CMt_Base::C_Attlist::SetAdditionalManifestFiles(void)
{
#ifdef _DEBUG
    if (!IsSetAdditionalManifestFiles()) {
        m_AdditionalManifestFiles = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10;
    return m_AdditionalManifestFiles;
}
 
inline
bool CMt_Base::C_Attlist::IsSetAdditionalOptions(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetAdditionalOptions(void) const
{
    return IsSetAdditionalOptions();
}
 
inline
const CMt_Base::C_Attlist::TAdditionalOptions& CMt_Base::C_Attlist::GetAdditionalOptions(void) const
{
    if (!CanGetAdditionalOptions()) {
        ThrowUnassigned(3);
    }
    return m_AdditionalOptions;
}
 
inline
void CMt_Base::C_Attlist::SetAdditionalOptions(const CMt_Base::C_Attlist::TAdditionalOptions& value)
{
    m_AdditionalOptions = value;
    m_set_State[0] |= 0xc0;
}
 
inline
void CMt_Base::C_Attlist::SetAdditionalOptions(CMt_Base::C_Attlist::TAdditionalOptions&& value)
{
    m_AdditionalOptions = std::forward<CMt_Base::C_Attlist::TAdditionalOptions>(value);
    m_set_State[0] |= 0xc0;
}
 
inline
CMt_Base::C_Attlist::TAdditionalOptions& CMt_Base::C_Attlist::SetAdditionalOptions(void)
{
#ifdef _DEBUG
    if (!IsSetAdditionalOptions()) {
        m_AdditionalOptions = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x40;
    return m_AdditionalOptions;
}
 
inline
bool CMt_Base::C_Attlist::IsSetAssemblyIdentity(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetAssemblyIdentity(void) const
{
    return IsSetAssemblyIdentity();
}
 
inline
const CMt_Base::C_Attlist::TAssemblyIdentity& CMt_Base::C_Attlist::GetAssemblyIdentity(void) const
{
    if (!CanGetAssemblyIdentity()) {
        ThrowUnassigned(4);
    }
    return m_AssemblyIdentity;
}
 
inline
void CMt_Base::C_Attlist::SetAssemblyIdentity(const CMt_Base::C_Attlist::TAssemblyIdentity& value)
{
    m_AssemblyIdentity = value;
    m_set_State[0] |= 0x300;
}
 
inline
void CMt_Base::C_Attlist::SetAssemblyIdentity(CMt_Base::C_Attlist::TAssemblyIdentity&& value)
{
    m_AssemblyIdentity = std::forward<CMt_Base::C_Attlist::TAssemblyIdentity>(value);
    m_set_State[0] |= 0x300;
}
 
inline
CMt_Base::C_Attlist::TAssemblyIdentity& CMt_Base::C_Attlist::SetAssemblyIdentity(void)
{
#ifdef _DEBUG
    if (!IsSetAssemblyIdentity()) {
        m_AssemblyIdentity = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x100;
    return m_AssemblyIdentity;
}
 
inline
bool CMt_Base::C_Attlist::IsSetComponentFileName(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetComponentFileName(void) const
{
    return IsSetComponentFileName();
}
 
inline
const CMt_Base::C_Attlist::TComponentFileName& CMt_Base::C_Attlist::GetComponentFileName(void) const
{
    if (!CanGetComponentFileName()) {
        ThrowUnassigned(5);
    }
    return m_ComponentFileName;
}
 
inline
void CMt_Base::C_Attlist::SetComponentFileName(const CMt_Base::C_Attlist::TComponentFileName& value)
{
    m_ComponentFileName = value;
    m_set_State[0] |= 0xc00;
}
 
inline
void CMt_Base::C_Attlist::SetComponentFileName(CMt_Base::C_Attlist::TComponentFileName&& value)
{
    m_ComponentFileName = std::forward<CMt_Base::C_Attlist::TComponentFileName>(value);
    m_set_State[0] |= 0xc00;
}
 
inline
CMt_Base::C_Attlist::TComponentFileName& CMt_Base::C_Attlist::SetComponentFileName(void)
{
#ifdef _DEBUG
    if (!IsSetComponentFileName()) {
        m_ComponentFileName = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x400;
    return m_ComponentFileName;
}
 
inline
bool CMt_Base::C_Attlist::IsSetEmbedManifest(void) const
{
    return ((m_set_State[0] & 0x3000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetEmbedManifest(void) const
{
    return IsSetEmbedManifest();
}
 
inline
const CMt_Base::C_Attlist::TEmbedManifest& CMt_Base::C_Attlist::GetEmbedManifest(void) const
{
    if (!CanGetEmbedManifest()) {
        ThrowUnassigned(6);
    }
    return m_EmbedManifest;
}
 
inline
void CMt_Base::C_Attlist::SetEmbedManifest(const CMt_Base::C_Attlist::TEmbedManifest& value)
{
    m_EmbedManifest = value;
    m_set_State[0] |= 0x3000;
}
 
inline
void CMt_Base::C_Attlist::SetEmbedManifest(CMt_Base::C_Attlist::TEmbedManifest&& value)
{
    m_EmbedManifest = std::forward<CMt_Base::C_Attlist::TEmbedManifest>(value);
    m_set_State[0] |= 0x3000;
}
 
inline
CMt_Base::C_Attlist::TEmbedManifest& CMt_Base::C_Attlist::SetEmbedManifest(void)
{
#ifdef _DEBUG
    if (!IsSetEmbedManifest()) {
        m_EmbedManifest = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x1000;
    return m_EmbedManifest;
}
 
inline
bool CMt_Base::C_Attlist::IsSetEnvironmentVariables(void) const
{
    return ((m_set_State[0] & 0xc000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetEnvironmentVariables(void) const
{
    return IsSetEnvironmentVariables();
}
 
inline
const CMt_Base::C_Attlist::TEnvironmentVariables& CMt_Base::C_Attlist::GetEnvironmentVariables(void) const
{
    if (!CanGetEnvironmentVariables()) {
        ThrowUnassigned(7);
    }
    return m_EnvironmentVariables;
}
 
inline
void CMt_Base::C_Attlist::SetEnvironmentVariables(const CMt_Base::C_Attlist::TEnvironmentVariables& value)
{
    m_EnvironmentVariables = value;
    m_set_State[0] |= 0xc000;
}
 
inline
void CMt_Base::C_Attlist::SetEnvironmentVariables(CMt_Base::C_Attlist::TEnvironmentVariables&& value)
{
    m_EnvironmentVariables = std::forward<CMt_Base::C_Attlist::TEnvironmentVariables>(value);
    m_set_State[0] |= 0xc000;
}
 
inline
CMt_Base::C_Attlist::TEnvironmentVariables& CMt_Base::C_Attlist::SetEnvironmentVariables(void)
{
#ifdef _DEBUG
    if (!IsSetEnvironmentVariables()) {
        m_EnvironmentVariables = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4000;
    return m_EnvironmentVariables;
}
 
inline
bool CMt_Base::C_Attlist::IsSetExcludedInputPaths(void) const
{
    return ((m_set_State[0] & 0x30000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetExcludedInputPaths(void) const
{
    return IsSetExcludedInputPaths();
}
 
inline
const CMt_Base::C_Attlist::TExcludedInputPaths& CMt_Base::C_Attlist::GetExcludedInputPaths(void) const
{
    if (!CanGetExcludedInputPaths()) {
        ThrowUnassigned(8);
    }
    return m_ExcludedInputPaths;
}
 
inline
void CMt_Base::C_Attlist::SetExcludedInputPaths(const CMt_Base::C_Attlist::TExcludedInputPaths& value)
{
    m_ExcludedInputPaths = value;
    m_set_State[0] |= 0x30000;
}
 
inline
void CMt_Base::C_Attlist::SetExcludedInputPaths(CMt_Base::C_Attlist::TExcludedInputPaths&& value)
{
    m_ExcludedInputPaths = std::forward<CMt_Base::C_Attlist::TExcludedInputPaths>(value);
    m_set_State[0] |= 0x30000;
}
 
inline
CMt_Base::C_Attlist::TExcludedInputPaths& CMt_Base::C_Attlist::SetExcludedInputPaths(void)
{
#ifdef _DEBUG
    if (!IsSetExcludedInputPaths()) {
        m_ExcludedInputPaths = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10000;
    return m_ExcludedInputPaths;
}
 
inline
bool CMt_Base::C_Attlist::IsSetGenerateCatalogFiles(void) const
{
    return ((m_set_State[0] & 0xc0000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetGenerateCatalogFiles(void) const
{
    return IsSetGenerateCatalogFiles();
}
 
inline
const CMt_Base::C_Attlist::TGenerateCatalogFiles& CMt_Base::C_Attlist::GetGenerateCatalogFiles(void) const
{
    if (!CanGetGenerateCatalogFiles()) {
        ThrowUnassigned(9);
    }
    return m_GenerateCatalogFiles;
}
 
inline
void CMt_Base::C_Attlist::SetGenerateCatalogFiles(const CMt_Base::C_Attlist::TGenerateCatalogFiles& value)
{
    m_GenerateCatalogFiles = value;
    m_set_State[0] |= 0xc0000;
}
 
inline
void CMt_Base::C_Attlist::SetGenerateCatalogFiles(CMt_Base::C_Attlist::TGenerateCatalogFiles&& value)
{
    m_GenerateCatalogFiles = std::forward<CMt_Base::C_Attlist::TGenerateCatalogFiles>(value);
    m_set_State[0] |= 0xc0000;
}
 
inline
CMt_Base::C_Attlist::TGenerateCatalogFiles& CMt_Base::C_Attlist::SetGenerateCatalogFiles(void)
{
#ifdef _DEBUG
    if (!IsSetGenerateCatalogFiles()) {
        m_GenerateCatalogFiles = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x40000;
    return m_GenerateCatalogFiles;
}
 
inline
bool CMt_Base::C_Attlist::IsSetGenerateCategoryTags(void) const
{
    return ((m_set_State[0] & 0x300000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetGenerateCategoryTags(void) const
{
    return IsSetGenerateCategoryTags();
}
 
inline
const CMt_Base::C_Attlist::TGenerateCategoryTags& CMt_Base::C_Attlist::GetGenerateCategoryTags(void) const
{
    if (!CanGetGenerateCategoryTags()) {
        ThrowUnassigned(10);
    }
    return m_GenerateCategoryTags;
}
 
inline
void CMt_Base::C_Attlist::SetGenerateCategoryTags(const CMt_Base::C_Attlist::TGenerateCategoryTags& value)
{
    m_GenerateCategoryTags = value;
    m_set_State[0] |= 0x300000;
}
 
inline
void CMt_Base::C_Attlist::SetGenerateCategoryTags(CMt_Base::C_Attlist::TGenerateCategoryTags&& value)
{
    m_GenerateCategoryTags = std::forward<CMt_Base::C_Attlist::TGenerateCategoryTags>(value);
    m_set_State[0] |= 0x300000;
}
 
inline
CMt_Base::C_Attlist::TGenerateCategoryTags& CMt_Base::C_Attlist::SetGenerateCategoryTags(void)
{
#ifdef _DEBUG
    if (!IsSetGenerateCategoryTags()) {
        m_GenerateCategoryTags = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x100000;
    return m_GenerateCategoryTags;
}
 
inline
bool CMt_Base::C_Attlist::IsSetInputResourceManifests(void) const
{
    return ((m_set_State[0] & 0xc00000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetInputResourceManifests(void) const
{
    return IsSetInputResourceManifests();
}
 
inline
const CMt_Base::C_Attlist::TInputResourceManifests& CMt_Base::C_Attlist::GetInputResourceManifests(void) const
{
    if (!CanGetInputResourceManifests()) {
        ThrowUnassigned(11);
    }
    return m_InputResourceManifests;
}
 
inline
void CMt_Base::C_Attlist::SetInputResourceManifests(const CMt_Base::C_Attlist::TInputResourceManifests& value)
{
    m_InputResourceManifests = value;
    m_set_State[0] |= 0xc00000;
}
 
inline
void CMt_Base::C_Attlist::SetInputResourceManifests(CMt_Base::C_Attlist::TInputResourceManifests&& value)
{
    m_InputResourceManifests = std::forward<CMt_Base::C_Attlist::TInputResourceManifests>(value);
    m_set_State[0] |= 0xc00000;
}
 
inline
CMt_Base::C_Attlist::TInputResourceManifests& CMt_Base::C_Attlist::SetInputResourceManifests(void)
{
#ifdef _DEBUG
    if (!IsSetInputResourceManifests()) {
        m_InputResourceManifests = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x400000;
    return m_InputResourceManifests;
}
 
inline
bool CMt_Base::C_Attlist::IsSetLogStandardErrorAsError(void) const
{
    return ((m_set_State[0] & 0x3000000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetLogStandardErrorAsError(void) const
{
    return IsSetLogStandardErrorAsError();
}
 
inline
const CMt_Base::C_Attlist::TLogStandardErrorAsError& CMt_Base::C_Attlist::GetLogStandardErrorAsError(void) const
{
    if (!CanGetLogStandardErrorAsError()) {
        ThrowUnassigned(12);
    }
    return m_LogStandardErrorAsError;
}
 
inline
void CMt_Base::C_Attlist::SetLogStandardErrorAsError(const CMt_Base::C_Attlist::TLogStandardErrorAsError& value)
{
    m_LogStandardErrorAsError = value;
    m_set_State[0] |= 0x3000000;
}
 
inline
void CMt_Base::C_Attlist::SetLogStandardErrorAsError(CMt_Base::C_Attlist::TLogStandardErrorAsError&& value)
{
    m_LogStandardErrorAsError = std::forward<CMt_Base::C_Attlist::TLogStandardErrorAsError>(value);
    m_set_State[0] |= 0x3000000;
}
 
inline
CMt_Base::C_Attlist::TLogStandardErrorAsError& CMt_Base::C_Attlist::SetLogStandardErrorAsError(void)
{
#ifdef _DEBUG
    if (!IsSetLogStandardErrorAsError()) {
        m_LogStandardErrorAsError = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x1000000;
    return m_LogStandardErrorAsError;
}
 
inline
bool CMt_Base::C_Attlist::IsSetManifestFromManagedAssembly(void) const
{
    return ((m_set_State[0] & 0xc000000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetManifestFromManagedAssembly(void) const
{
    return IsSetManifestFromManagedAssembly();
}
 
inline
const CMt_Base::C_Attlist::TManifestFromManagedAssembly& CMt_Base::C_Attlist::GetManifestFromManagedAssembly(void) const
{
    if (!CanGetManifestFromManagedAssembly()) {
        ThrowUnassigned(13);
    }
    return m_ManifestFromManagedAssembly;
}
 
inline
void CMt_Base::C_Attlist::SetManifestFromManagedAssembly(const CMt_Base::C_Attlist::TManifestFromManagedAssembly& value)
{
    m_ManifestFromManagedAssembly = value;
    m_set_State[0] |= 0xc000000;
}
 
inline
void CMt_Base::C_Attlist::SetManifestFromManagedAssembly(CMt_Base::C_Attlist::TManifestFromManagedAssembly&& value)
{
    m_ManifestFromManagedAssembly = std::forward<CMt_Base::C_Attlist::TManifestFromManagedAssembly>(value);
    m_set_State[0] |= 0xc000000;
}
 
inline
CMt_Base::C_Attlist::TManifestFromManagedAssembly& CMt_Base::C_Attlist::SetManifestFromManagedAssembly(void)
{
#ifdef _DEBUG
    if (!IsSetManifestFromManagedAssembly()) {
        m_ManifestFromManagedAssembly = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4000000;
    return m_ManifestFromManagedAssembly;
}
 
inline
bool CMt_Base::C_Attlist::IsSetMinimalRebuildFromTracking(void) const
{
    return ((m_set_State[0] & 0x30000000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetMinimalRebuildFromTracking(void) const
{
    return IsSetMinimalRebuildFromTracking();
}
 
inline
const CMt_Base::C_Attlist::TMinimalRebuildFromTracking& CMt_Base::C_Attlist::GetMinimalRebuildFromTracking(void) const
{
    if (!CanGetMinimalRebuildFromTracking()) {
        ThrowUnassigned(14);
    }
    return m_MinimalRebuildFromTracking;
}
 
inline
void CMt_Base::C_Attlist::SetMinimalRebuildFromTracking(const CMt_Base::C_Attlist::TMinimalRebuildFromTracking& value)
{
    m_MinimalRebuildFromTracking = value;
    m_set_State[0] |= 0x30000000;
}
 
inline
void CMt_Base::C_Attlist::SetMinimalRebuildFromTracking(CMt_Base::C_Attlist::TMinimalRebuildFromTracking&& value)
{
    m_MinimalRebuildFromTracking = std::forward<CMt_Base::C_Attlist::TMinimalRebuildFromTracking>(value);
    m_set_State[0] |= 0x30000000;
}
 
inline
CMt_Base::C_Attlist::TMinimalRebuildFromTracking& CMt_Base::C_Attlist::SetMinimalRebuildFromTracking(void)
{
#ifdef _DEBUG
    if (!IsSetMinimalRebuildFromTracking()) {
        m_MinimalRebuildFromTracking = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10000000;
    return m_MinimalRebuildFromTracking;
}
 
inline
bool CMt_Base::C_Attlist::IsSetOutputManifestFile(void) const
{
    return ((m_set_State[0] & 0xc0000000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetOutputManifestFile(void) const
{
    return IsSetOutputManifestFile();
}
 
inline
const CMt_Base::C_Attlist::TOutputManifestFile& CMt_Base::C_Attlist::GetOutputManifestFile(void) const
{
    if (!CanGetOutputManifestFile()) {
        ThrowUnassigned(15);
    }
    return m_OutputManifestFile;
}
 
inline
void CMt_Base::C_Attlist::SetOutputManifestFile(const CMt_Base::C_Attlist::TOutputManifestFile& value)
{
    m_OutputManifestFile = value;
    m_set_State[0] |= 0xc0000000;
}
 
inline
void CMt_Base::C_Attlist::SetOutputManifestFile(CMt_Base::C_Attlist::TOutputManifestFile&& value)
{
    m_OutputManifestFile = std::forward<CMt_Base::C_Attlist::TOutputManifestFile>(value);
    m_set_State[0] |= 0xc0000000;
}
 
inline
CMt_Base::C_Attlist::TOutputManifestFile& CMt_Base::C_Attlist::SetOutputManifestFile(void)
{
#ifdef _DEBUG
    if (!IsSetOutputManifestFile()) {
        m_OutputManifestFile = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x40000000;
    return m_OutputManifestFile;
}
 
inline
bool CMt_Base::C_Attlist::IsSetOutputResourceManifests(void) const
{
    return ((m_set_State[1] & 0x3) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetOutputResourceManifests(void) const
{
    return IsSetOutputResourceManifests();
}
 
inline
const CMt_Base::C_Attlist::TOutputResourceManifests& CMt_Base::C_Attlist::GetOutputResourceManifests(void) const
{
    if (!CanGetOutputResourceManifests()) {
        ThrowUnassigned(16);
    }
    return m_OutputResourceManifests;
}
 
inline
void CMt_Base::C_Attlist::SetOutputResourceManifests(const CMt_Base::C_Attlist::TOutputResourceManifests& value)
{
    m_OutputResourceManifests = value;
    m_set_State[1] |= 0x3;
}
 
inline
void CMt_Base::C_Attlist::SetOutputResourceManifests(CMt_Base::C_Attlist::TOutputResourceManifests&& value)
{
    m_OutputResourceManifests = std::forward<CMt_Base::C_Attlist::TOutputResourceManifests>(value);
    m_set_State[1] |= 0x3;
}
 
inline
CMt_Base::C_Attlist::TOutputResourceManifests& CMt_Base::C_Attlist::SetOutputResourceManifests(void)
{
#ifdef _DEBUG
    if (!IsSetOutputResourceManifests()) {
        m_OutputResourceManifests = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x1;
    return m_OutputResourceManifests;
}
 
inline
bool CMt_Base::C_Attlist::IsSetPathOverride(void) const
{
    return ((m_set_State[1] & 0xc) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetPathOverride(void) const
{
    return IsSetPathOverride();
}
 
inline
const CMt_Base::C_Attlist::TPathOverride& CMt_Base::C_Attlist::GetPathOverride(void) const
{
    if (!CanGetPathOverride()) {
        ThrowUnassigned(17);
    }
    return m_PathOverride;
}
 
inline
void CMt_Base::C_Attlist::SetPathOverride(const CMt_Base::C_Attlist::TPathOverride& value)
{
    m_PathOverride = value;
    m_set_State[1] |= 0xc;
}
 
inline
void CMt_Base::C_Attlist::SetPathOverride(CMt_Base::C_Attlist::TPathOverride&& value)
{
    m_PathOverride = std::forward<CMt_Base::C_Attlist::TPathOverride>(value);
    m_set_State[1] |= 0xc;
}
 
inline
CMt_Base::C_Attlist::TPathOverride& CMt_Base::C_Attlist::SetPathOverride(void)
{
#ifdef _DEBUG
    if (!IsSetPathOverride()) {
        m_PathOverride = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x4;
    return m_PathOverride;
}
 
inline
bool CMt_Base::C_Attlist::IsSetRegistrarScriptFile(void) const
{
    return ((m_set_State[1] & 0x30) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetRegistrarScriptFile(void) const
{
    return IsSetRegistrarScriptFile();
}
 
inline
const CMt_Base::C_Attlist::TRegistrarScriptFile& CMt_Base::C_Attlist::GetRegistrarScriptFile(void) const
{
    if (!CanGetRegistrarScriptFile()) {
        ThrowUnassigned(18);
    }
    return m_RegistrarScriptFile;
}
 
inline
void CMt_Base::C_Attlist::SetRegistrarScriptFile(const CMt_Base::C_Attlist::TRegistrarScriptFile& value)
{
    m_RegistrarScriptFile = value;
    m_set_State[1] |= 0x30;
}
 
inline
void CMt_Base::C_Attlist::SetRegistrarScriptFile(CMt_Base::C_Attlist::TRegistrarScriptFile&& value)
{
    m_RegistrarScriptFile = std::forward<CMt_Base::C_Attlist::TRegistrarScriptFile>(value);
    m_set_State[1] |= 0x30;
}
 
inline
CMt_Base::C_Attlist::TRegistrarScriptFile& CMt_Base::C_Attlist::SetRegistrarScriptFile(void)
{
#ifdef _DEBUG
    if (!IsSetRegistrarScriptFile()) {
        m_RegistrarScriptFile = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x10;
    return m_RegistrarScriptFile;
}
 
inline
bool CMt_Base::C_Attlist::IsSetReplacementsFile(void) const
{
    return ((m_set_State[1] & 0xc0) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetReplacementsFile(void) const
{
    return IsSetReplacementsFile();
}
 
inline
const CMt_Base::C_Attlist::TReplacementsFile& CMt_Base::C_Attlist::GetReplacementsFile(void) const
{
    if (!CanGetReplacementsFile()) {
        ThrowUnassigned(19);
    }
    return m_ReplacementsFile;
}
 
inline
void CMt_Base::C_Attlist::SetReplacementsFile(const CMt_Base::C_Attlist::TReplacementsFile& value)
{
    m_ReplacementsFile = value;
    m_set_State[1] |= 0xc0;
}
 
inline
void CMt_Base::C_Attlist::SetReplacementsFile(CMt_Base::C_Attlist::TReplacementsFile&& value)
{
    m_ReplacementsFile = std::forward<CMt_Base::C_Attlist::TReplacementsFile>(value);
    m_set_State[1] |= 0xc0;
}
 
inline
CMt_Base::C_Attlist::TReplacementsFile& CMt_Base::C_Attlist::SetReplacementsFile(void)
{
#ifdef _DEBUG
    if (!IsSetReplacementsFile()) {
        m_ReplacementsFile = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x40;
    return m_ReplacementsFile;
}
 
inline
bool CMt_Base::C_Attlist::IsSetResourceOutputFileName(void) const
{
    return ((m_set_State[1] & 0x300) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetResourceOutputFileName(void) const
{
    return IsSetResourceOutputFileName();
}
 
inline
const CMt_Base::C_Attlist::TResourceOutputFileName& CMt_Base::C_Attlist::GetResourceOutputFileName(void) const
{
    if (!CanGetResourceOutputFileName()) {
        ThrowUnassigned(20);
    }
    return m_ResourceOutputFileName;
}
 
inline
void CMt_Base::C_Attlist::SetResourceOutputFileName(const CMt_Base::C_Attlist::TResourceOutputFileName& value)
{
    m_ResourceOutputFileName = value;
    m_set_State[1] |= 0x300;
}
 
inline
void CMt_Base::C_Attlist::SetResourceOutputFileName(CMt_Base::C_Attlist::TResourceOutputFileName&& value)
{
    m_ResourceOutputFileName = std::forward<CMt_Base::C_Attlist::TResourceOutputFileName>(value);
    m_set_State[1] |= 0x300;
}
 
inline
CMt_Base::C_Attlist::TResourceOutputFileName& CMt_Base::C_Attlist::SetResourceOutputFileName(void)
{
#ifdef _DEBUG
    if (!IsSetResourceOutputFileName()) {
        m_ResourceOutputFileName = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x100;
    return m_ResourceOutputFileName;
}
 
inline
bool CMt_Base::C_Attlist::IsSetSkippedExecution(void) const
{
    return ((m_set_State[1] & 0xc00) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetSkippedExecution(void) const
{
    return IsSetSkippedExecution();
}
 
inline
const CMt_Base::C_Attlist::TSkippedExecution& CMt_Base::C_Attlist::GetSkippedExecution(void) const
{
    if (!CanGetSkippedExecution()) {
        ThrowUnassigned(21);
    }
    return m_SkippedExecution;
}
 
inline
void CMt_Base::C_Attlist::SetSkippedExecution(const CMt_Base::C_Attlist::TSkippedExecution& value)
{
    m_SkippedExecution = value;
    m_set_State[1] |= 0xc00;
}
 
inline
void CMt_Base::C_Attlist::SetSkippedExecution(CMt_Base::C_Attlist::TSkippedExecution&& value)
{
    m_SkippedExecution = std::forward<CMt_Base::C_Attlist::TSkippedExecution>(value);
    m_set_State[1] |= 0xc00;
}
 
inline
CMt_Base::C_Attlist::TSkippedExecution& CMt_Base::C_Attlist::SetSkippedExecution(void)
{
#ifdef _DEBUG
    if (!IsSetSkippedExecution()) {
        m_SkippedExecution = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x400;
    return m_SkippedExecution;
}
 
inline
bool CMt_Base::C_Attlist::IsSetSources(void) const
{
    return ((m_set_State[1] & 0x3000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetSources(void) const
{
    return IsSetSources();
}
 
inline
const CMt_Base::C_Attlist::TSources& CMt_Base::C_Attlist::GetSources(void) const
{
    if (!CanGetSources()) {
        ThrowUnassigned(22);
    }
    return m_Sources;
}
 
inline
void CMt_Base::C_Attlist::SetSources(const CMt_Base::C_Attlist::TSources& value)
{
    m_Sources = value;
    m_set_State[1] |= 0x3000;
}
 
inline
void CMt_Base::C_Attlist::SetSources(CMt_Base::C_Attlist::TSources&& value)
{
    m_Sources = std::forward<CMt_Base::C_Attlist::TSources>(value);
    m_set_State[1] |= 0x3000;
}
 
inline
CMt_Base::C_Attlist::TSources& CMt_Base::C_Attlist::SetSources(void)
{
#ifdef _DEBUG
    if (!IsSetSources()) {
        m_Sources = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x1000;
    return m_Sources;
}
 
inline
bool CMt_Base::C_Attlist::IsSetSourcesCompiled(void) const
{
    return ((m_set_State[1] & 0xc000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetSourcesCompiled(void) const
{
    return IsSetSourcesCompiled();
}
 
inline
const CMt_Base::C_Attlist::TSourcesCompiled& CMt_Base::C_Attlist::GetSourcesCompiled(void) const
{
    if (!CanGetSourcesCompiled()) {
        ThrowUnassigned(23);
    }
    return m_SourcesCompiled;
}
 
inline
void CMt_Base::C_Attlist::SetSourcesCompiled(const CMt_Base::C_Attlist::TSourcesCompiled& value)
{
    m_SourcesCompiled = value;
    m_set_State[1] |= 0xc000;
}
 
inline
void CMt_Base::C_Attlist::SetSourcesCompiled(CMt_Base::C_Attlist::TSourcesCompiled&& value)
{
    m_SourcesCompiled = std::forward<CMt_Base::C_Attlist::TSourcesCompiled>(value);
    m_set_State[1] |= 0xc000;
}
 
inline
CMt_Base::C_Attlist::TSourcesCompiled& CMt_Base::C_Attlist::SetSourcesCompiled(void)
{
#ifdef _DEBUG
    if (!IsSetSourcesCompiled()) {
        m_SourcesCompiled = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x4000;
    return m_SourcesCompiled;
}
 
inline
bool CMt_Base::C_Attlist::IsSetStandardErrorImportance(void) const
{
    return ((m_set_State[1] & 0x30000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetStandardErrorImportance(void) const
{
    return IsSetStandardErrorImportance();
}
 
inline
const CMt_Base::C_Attlist::TStandardErrorImportance& CMt_Base::C_Attlist::GetStandardErrorImportance(void) const
{
    if (!CanGetStandardErrorImportance()) {
        ThrowUnassigned(24);
    }
    return m_StandardErrorImportance;
}
 
inline
void CMt_Base::C_Attlist::SetStandardErrorImportance(const CMt_Base::C_Attlist::TStandardErrorImportance& value)
{
    m_StandardErrorImportance = value;
    m_set_State[1] |= 0x30000;
}
 
inline
void CMt_Base::C_Attlist::SetStandardErrorImportance(CMt_Base::C_Attlist::TStandardErrorImportance&& value)
{
    m_StandardErrorImportance = std::forward<CMt_Base::C_Attlist::TStandardErrorImportance>(value);
    m_set_State[1] |= 0x30000;
}
 
inline
CMt_Base::C_Attlist::TStandardErrorImportance& CMt_Base::C_Attlist::SetStandardErrorImportance(void)
{
#ifdef _DEBUG
    if (!IsSetStandardErrorImportance()) {
        m_StandardErrorImportance = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x10000;
    return m_StandardErrorImportance;
}
 
inline
bool CMt_Base::C_Attlist::IsSetStandardOutputImportance(void) const
{
    return ((m_set_State[1] & 0xc0000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetStandardOutputImportance(void) const
{
    return IsSetStandardOutputImportance();
}
 
inline
const CMt_Base::C_Attlist::TStandardOutputImportance& CMt_Base::C_Attlist::GetStandardOutputImportance(void) const
{
    if (!CanGetStandardOutputImportance()) {
        ThrowUnassigned(25);
    }
    return m_StandardOutputImportance;
}
 
inline
void CMt_Base::C_Attlist::SetStandardOutputImportance(const CMt_Base::C_Attlist::TStandardOutputImportance& value)
{
    m_StandardOutputImportance = value;
    m_set_State[1] |= 0xc0000;
}
 
inline
void CMt_Base::C_Attlist::SetStandardOutputImportance(CMt_Base::C_Attlist::TStandardOutputImportance&& value)
{
    m_StandardOutputImportance = std::forward<CMt_Base::C_Attlist::TStandardOutputImportance>(value);
    m_set_State[1] |= 0xc0000;
}
 
inline
CMt_Base::C_Attlist::TStandardOutputImportance& CMt_Base::C_Attlist::SetStandardOutputImportance(void)
{
#ifdef _DEBUG
    if (!IsSetStandardOutputImportance()) {
        m_StandardOutputImportance = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x40000;
    return m_StandardOutputImportance;
}
 
inline
bool CMt_Base::C_Attlist::IsSetSuppressDependencyElement(void) const
{
    return ((m_set_State[1] & 0x300000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetSuppressDependencyElement(void) const
{
    return IsSetSuppressDependencyElement();
}
 
inline
const CMt_Base::C_Attlist::TSuppressDependencyElement& CMt_Base::C_Attlist::GetSuppressDependencyElement(void) const
{
    if (!CanGetSuppressDependencyElement()) {
        ThrowUnassigned(26);
    }
    return m_SuppressDependencyElement;
}
 
inline
void CMt_Base::C_Attlist::SetSuppressDependencyElement(const CMt_Base::C_Attlist::TSuppressDependencyElement& value)
{
    m_SuppressDependencyElement = value;
    m_set_State[1] |= 0x300000;
}
 
inline
void CMt_Base::C_Attlist::SetSuppressDependencyElement(CMt_Base::C_Attlist::TSuppressDependencyElement&& value)
{
    m_SuppressDependencyElement = std::forward<CMt_Base::C_Attlist::TSuppressDependencyElement>(value);
    m_set_State[1] |= 0x300000;
}
 
inline
CMt_Base::C_Attlist::TSuppressDependencyElement& CMt_Base::C_Attlist::SetSuppressDependencyElement(void)
{
#ifdef _DEBUG
    if (!IsSetSuppressDependencyElement()) {
        m_SuppressDependencyElement = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x100000;
    return m_SuppressDependencyElement;
}
 
inline
bool CMt_Base::C_Attlist::IsSetSuppressStartupBanner(void) const
{
    return ((m_set_State[1] & 0xc00000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetSuppressStartupBanner(void) const
{
    return IsSetSuppressStartupBanner();
}
 
inline
const CMt_Base::C_Attlist::TSuppressStartupBanner& CMt_Base::C_Attlist::GetSuppressStartupBanner(void) const
{
    if (!CanGetSuppressStartupBanner()) {
        ThrowUnassigned(27);
    }
    return m_SuppressStartupBanner;
}
 
inline
void CMt_Base::C_Attlist::SetSuppressStartupBanner(const CMt_Base::C_Attlist::TSuppressStartupBanner& value)
{
    m_SuppressStartupBanner = value;
    m_set_State[1] |= 0xc00000;
}
 
inline
void CMt_Base::C_Attlist::SetSuppressStartupBanner(CMt_Base::C_Attlist::TSuppressStartupBanner&& value)
{
    m_SuppressStartupBanner = std::forward<CMt_Base::C_Attlist::TSuppressStartupBanner>(value);
    m_set_State[1] |= 0xc00000;
}
 
inline
CMt_Base::C_Attlist::TSuppressStartupBanner& CMt_Base::C_Attlist::SetSuppressStartupBanner(void)
{
#ifdef _DEBUG
    if (!IsSetSuppressStartupBanner()) {
        m_SuppressStartupBanner = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x400000;
    return m_SuppressStartupBanner;
}
 
inline
bool CMt_Base::C_Attlist::IsSetTimeout(void) const
{
    return ((m_set_State[1] & 0x3000000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetTimeout(void) const
{
    return IsSetTimeout();
}
 
inline
const CMt_Base::C_Attlist::TTimeout& CMt_Base::C_Attlist::GetTimeout(void) const
{
    if (!CanGetTimeout()) {
        ThrowUnassigned(28);
    }
    return m_Timeout;
}
 
inline
void CMt_Base::C_Attlist::SetTimeout(const CMt_Base::C_Attlist::TTimeout& value)
{
    m_Timeout = value;
    m_set_State[1] |= 0x3000000;
}
 
inline
void CMt_Base::C_Attlist::SetTimeout(CMt_Base::C_Attlist::TTimeout&& value)
{
    m_Timeout = std::forward<CMt_Base::C_Attlist::TTimeout>(value);
    m_set_State[1] |= 0x3000000;
}
 
inline
CMt_Base::C_Attlist::TTimeout& CMt_Base::C_Attlist::SetTimeout(void)
{
#ifdef _DEBUG
    if (!IsSetTimeout()) {
        m_Timeout = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x1000000;
    return m_Timeout;
}
 
inline
bool CMt_Base::C_Attlist::IsSetTLogReadFiles(void) const
{
    return ((m_set_State[1] & 0xc000000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetTLogReadFiles(void) const
{
    return IsSetTLogReadFiles();
}
 
inline
const CMt_Base::C_Attlist::TTLogReadFiles& CMt_Base::C_Attlist::GetTLogReadFiles(void) const
{
    if (!CanGetTLogReadFiles()) {
        ThrowUnassigned(29);
    }
    return m_TLogReadFiles;
}
 
inline
void CMt_Base::C_Attlist::SetTLogReadFiles(const CMt_Base::C_Attlist::TTLogReadFiles& value)
{
    m_TLogReadFiles = value;
    m_set_State[1] |= 0xc000000;
}
 
inline
void CMt_Base::C_Attlist::SetTLogReadFiles(CMt_Base::C_Attlist::TTLogReadFiles&& value)
{
    m_TLogReadFiles = std::forward<CMt_Base::C_Attlist::TTLogReadFiles>(value);
    m_set_State[1] |= 0xc000000;
}
 
inline
CMt_Base::C_Attlist::TTLogReadFiles& CMt_Base::C_Attlist::SetTLogReadFiles(void)
{
#ifdef _DEBUG
    if (!IsSetTLogReadFiles()) {
        m_TLogReadFiles = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x4000000;
    return m_TLogReadFiles;
}
 
inline
bool CMt_Base::C_Attlist::IsSetTLogWriteFiles(void) const
{
    return ((m_set_State[1] & 0x30000000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetTLogWriteFiles(void) const
{
    return IsSetTLogWriteFiles();
}
 
inline
const CMt_Base::C_Attlist::TTLogWriteFiles& CMt_Base::C_Attlist::GetTLogWriteFiles(void) const
{
    if (!CanGetTLogWriteFiles()) {
        ThrowUnassigned(30);
    }
    return m_TLogWriteFiles;
}
 
inline
void CMt_Base::C_Attlist::SetTLogWriteFiles(const CMt_Base::C_Attlist::TTLogWriteFiles& value)
{
    m_TLogWriteFiles = value;
    m_set_State[1] |= 0x30000000;
}
 
inline
void CMt_Base::C_Attlist::SetTLogWriteFiles(CMt_Base::C_Attlist::TTLogWriteFiles&& value)
{
    m_TLogWriteFiles = std::forward<CMt_Base::C_Attlist::TTLogWriteFiles>(value);
    m_set_State[1] |= 0x30000000;
}
 
inline
CMt_Base::C_Attlist::TTLogWriteFiles& CMt_Base::C_Attlist::SetTLogWriteFiles(void)
{
#ifdef _DEBUG
    if (!IsSetTLogWriteFiles()) {
        m_TLogWriteFiles = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x10000000;
    return m_TLogWriteFiles;
}
 
inline
bool CMt_Base::C_Attlist::IsSetToolExe(void) const
{
    return ((m_set_State[1] & 0xc0000000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetToolExe(void) const
{
    return IsSetToolExe();
}
 
inline
const CMt_Base::C_Attlist::TToolExe& CMt_Base::C_Attlist::GetToolExe(void) const
{
    if (!CanGetToolExe()) {
        ThrowUnassigned(31);
    }
    return m_ToolExe;
}
 
inline
void CMt_Base::C_Attlist::SetToolExe(const CMt_Base::C_Attlist::TToolExe& value)
{
    m_ToolExe = value;
    m_set_State[1] |= 0xc0000000;
}
 
inline
void CMt_Base::C_Attlist::SetToolExe(CMt_Base::C_Attlist::TToolExe&& value)
{
    m_ToolExe = std::forward<CMt_Base::C_Attlist::TToolExe>(value);
    m_set_State[1] |= 0xc0000000;
}
 
inline
CMt_Base::C_Attlist::TToolExe& CMt_Base::C_Attlist::SetToolExe(void)
{
#ifdef _DEBUG
    if (!IsSetToolExe()) {
        m_ToolExe = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x40000000;
    return m_ToolExe;
}
 
inline
bool CMt_Base::C_Attlist::IsSetToolPath(void) const
{
    return ((m_set_State[2] & 0x3) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetToolPath(void) const
{
    return IsSetToolPath();
}
 
inline
const CMt_Base::C_Attlist::TToolPath& CMt_Base::C_Attlist::GetToolPath(void) const
{
    if (!CanGetToolPath()) {
        ThrowUnassigned(32);
    }
    return m_ToolPath;
}
 
inline
void CMt_Base::C_Attlist::SetToolPath(const CMt_Base::C_Attlist::TToolPath& value)
{
    m_ToolPath = value;
    m_set_State[2] |= 0x3;
}
 
inline
void CMt_Base::C_Attlist::SetToolPath(CMt_Base::C_Attlist::TToolPath&& value)
{
    m_ToolPath = std::forward<CMt_Base::C_Attlist::TToolPath>(value);
    m_set_State[2] |= 0x3;
}
 
inline
CMt_Base::C_Attlist::TToolPath& CMt_Base::C_Attlist::SetToolPath(void)
{
#ifdef _DEBUG
    if (!IsSetToolPath()) {
        m_ToolPath = UnassignedString();
    }
#endif
    m_set_State[2] |= 0x1;
    return m_ToolPath;
}
 
inline
bool CMt_Base::C_Attlist::IsSetTrackedInputFilesToIgnore(void) const
{
    return ((m_set_State[2] & 0xc) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetTrackedInputFilesToIgnore(void) const
{
    return IsSetTrackedInputFilesToIgnore();
}
 
inline
const CMt_Base::C_Attlist::TTrackedInputFilesToIgnore& CMt_Base::C_Attlist::GetTrackedInputFilesToIgnore(void) const
{
    if (!CanGetTrackedInputFilesToIgnore()) {
        ThrowUnassigned(33);
    }
    return m_TrackedInputFilesToIgnore;
}
 
inline
void CMt_Base::C_Attlist::SetTrackedInputFilesToIgnore(const CMt_Base::C_Attlist::TTrackedInputFilesToIgnore& value)
{
    m_TrackedInputFilesToIgnore = value;
    m_set_State[2] |= 0xc;
}
 
inline
void CMt_Base::C_Attlist::SetTrackedInputFilesToIgnore(CMt_Base::C_Attlist::TTrackedInputFilesToIgnore&& value)
{
    m_TrackedInputFilesToIgnore = std::forward<CMt_Base::C_Attlist::TTrackedInputFilesToIgnore>(value);
    m_set_State[2] |= 0xc;
}
 
inline
CMt_Base::C_Attlist::TTrackedInputFilesToIgnore& CMt_Base::C_Attlist::SetTrackedInputFilesToIgnore(void)
{
#ifdef _DEBUG
    if (!IsSetTrackedInputFilesToIgnore()) {
        m_TrackedInputFilesToIgnore = UnassignedString();
    }
#endif
    m_set_State[2] |= 0x4;
    return m_TrackedInputFilesToIgnore;
}
 
inline
bool CMt_Base::C_Attlist::IsSetTrackedOutputFilesToIgnore(void) const
{
    return ((m_set_State[2] & 0x30) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetTrackedOutputFilesToIgnore(void) const
{
    return IsSetTrackedOutputFilesToIgnore();
}
 
inline
const CMt_Base::C_Attlist::TTrackedOutputFilesToIgnore& CMt_Base::C_Attlist::GetTrackedOutputFilesToIgnore(void) const
{
    if (!CanGetTrackedOutputFilesToIgnore()) {
        ThrowUnassigned(34);
    }
    return m_TrackedOutputFilesToIgnore;
}
 
inline
void CMt_Base::C_Attlist::SetTrackedOutputFilesToIgnore(const CMt_Base::C_Attlist::TTrackedOutputFilesToIgnore& value)
{
    m_TrackedOutputFilesToIgnore = value;
    m_set_State[2] |= 0x30;
}
 
inline
void CMt_Base::C_Attlist::SetTrackedOutputFilesToIgnore(CMt_Base::C_Attlist::TTrackedOutputFilesToIgnore&& value)
{
    m_TrackedOutputFilesToIgnore = std::forward<CMt_Base::C_Attlist::TTrackedOutputFilesToIgnore>(value);
    m_set_State[2] |= 0x30;
}
 
inline
CMt_Base::C_Attlist::TTrackedOutputFilesToIgnore& CMt_Base::C_Attlist::SetTrackedOutputFilesToIgnore(void)
{
#ifdef _DEBUG
    if (!IsSetTrackedOutputFilesToIgnore()) {
        m_TrackedOutputFilesToIgnore = UnassignedString();
    }
#endif
    m_set_State[2] |= 0x10;
    return m_TrackedOutputFilesToIgnore;
}
 
inline
bool CMt_Base::C_Attlist::IsSetTrackerLogDirectory(void) const
{
    return ((m_set_State[2] & 0xc0) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetTrackerLogDirectory(void) const
{
    return IsSetTrackerLogDirectory();
}
 
inline
const CMt_Base::C_Attlist::TTrackerLogDirectory& CMt_Base::C_Attlist::GetTrackerLogDirectory(void) const
{
    if (!CanGetTrackerLogDirectory()) {
        ThrowUnassigned(35);
    }
    return m_TrackerLogDirectory;
}
 
inline
void CMt_Base::C_Attlist::SetTrackerLogDirectory(const CMt_Base::C_Attlist::TTrackerLogDirectory& value)
{
    m_TrackerLogDirectory = value;
    m_set_State[2] |= 0xc0;
}
 
inline
void CMt_Base::C_Attlist::SetTrackerLogDirectory(CMt_Base::C_Attlist::TTrackerLogDirectory&& value)
{
    m_TrackerLogDirectory = std::forward<CMt_Base::C_Attlist::TTrackerLogDirectory>(value);
    m_set_State[2] |= 0xc0;
}
 
inline
CMt_Base::C_Attlist::TTrackerLogDirectory& CMt_Base::C_Attlist::SetTrackerLogDirectory(void)
{
#ifdef _DEBUG
    if (!IsSetTrackerLogDirectory()) {
        m_TrackerLogDirectory = UnassignedString();
    }
#endif
    m_set_State[2] |= 0x40;
    return m_TrackerLogDirectory;
}
 
inline
bool CMt_Base::C_Attlist::IsSetTrackFileAccess(void) const
{
    return ((m_set_State[2] & 0x300) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetTrackFileAccess(void) const
{
    return IsSetTrackFileAccess();
}
 
inline
const CMt_Base::C_Attlist::TTrackFileAccess& CMt_Base::C_Attlist::GetTrackFileAccess(void) const
{
    if (!CanGetTrackFileAccess()) {
        ThrowUnassigned(36);
    }
    return m_TrackFileAccess;
}
 
inline
void CMt_Base::C_Attlist::SetTrackFileAccess(const CMt_Base::C_Attlist::TTrackFileAccess& value)
{
    m_TrackFileAccess = value;
    m_set_State[2] |= 0x300;
}
 
inline
void CMt_Base::C_Attlist::SetTrackFileAccess(CMt_Base::C_Attlist::TTrackFileAccess&& value)
{
    m_TrackFileAccess = std::forward<CMt_Base::C_Attlist::TTrackFileAccess>(value);
    m_set_State[2] |= 0x300;
}
 
inline
CMt_Base::C_Attlist::TTrackFileAccess& CMt_Base::C_Attlist::SetTrackFileAccess(void)
{
#ifdef _DEBUG
    if (!IsSetTrackFileAccess()) {
        m_TrackFileAccess = UnassignedString();
    }
#endif
    m_set_State[2] |= 0x100;
    return m_TrackFileAccess;
}
 
inline
bool CMt_Base::C_Attlist::IsSetTypeLibraryFile(void) const
{
    return ((m_set_State[2] & 0xc00) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetTypeLibraryFile(void) const
{
    return IsSetTypeLibraryFile();
}
 
inline
const CMt_Base::C_Attlist::TTypeLibraryFile& CMt_Base::C_Attlist::GetTypeLibraryFile(void) const
{
    if (!CanGetTypeLibraryFile()) {
        ThrowUnassigned(37);
    }
    return m_TypeLibraryFile;
}
 
inline
void CMt_Base::C_Attlist::SetTypeLibraryFile(const CMt_Base::C_Attlist::TTypeLibraryFile& value)
{
    m_TypeLibraryFile = value;
    m_set_State[2] |= 0xc00;
}
 
inline
void CMt_Base::C_Attlist::SetTypeLibraryFile(CMt_Base::C_Attlist::TTypeLibraryFile&& value)
{
    m_TypeLibraryFile = std::forward<CMt_Base::C_Attlist::TTypeLibraryFile>(value);
    m_set_State[2] |= 0xc00;
}
 
inline
CMt_Base::C_Attlist::TTypeLibraryFile& CMt_Base::C_Attlist::SetTypeLibraryFile(void)
{
#ifdef _DEBUG
    if (!IsSetTypeLibraryFile()) {
        m_TypeLibraryFile = UnassignedString();
    }
#endif
    m_set_State[2] |= 0x400;
    return m_TypeLibraryFile;
}
 
inline
bool CMt_Base::C_Attlist::IsSetUpdateFileHashes(void) const
{
    return ((m_set_State[2] & 0x3000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetUpdateFileHashes(void) const
{
    return IsSetUpdateFileHashes();
}
 
inline
const CMt_Base::C_Attlist::TUpdateFileHashes& CMt_Base::C_Attlist::GetUpdateFileHashes(void) const
{
    if (!CanGetUpdateFileHashes()) {
        ThrowUnassigned(38);
    }
    return m_UpdateFileHashes;
}
 
inline
void CMt_Base::C_Attlist::SetUpdateFileHashes(const CMt_Base::C_Attlist::TUpdateFileHashes& value)
{
    m_UpdateFileHashes = value;
    m_set_State[2] |= 0x3000;
}
 
inline
void CMt_Base::C_Attlist::SetUpdateFileHashes(CMt_Base::C_Attlist::TUpdateFileHashes&& value)
{
    m_UpdateFileHashes = std::forward<CMt_Base::C_Attlist::TUpdateFileHashes>(value);
    m_set_State[2] |= 0x3000;
}
 
inline
CMt_Base::C_Attlist::TUpdateFileHashes& CMt_Base::C_Attlist::SetUpdateFileHashes(void)
{
#ifdef _DEBUG
    if (!IsSetUpdateFileHashes()) {
        m_UpdateFileHashes = UnassignedString();
    }
#endif
    m_set_State[2] |= 0x1000;
    return m_UpdateFileHashes;
}
 
inline
bool CMt_Base::C_Attlist::IsSetUpdateFileHashesSearchPath(void) const
{
    return ((m_set_State[2] & 0xc000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetUpdateFileHashesSearchPath(void) const
{
    return IsSetUpdateFileHashesSearchPath();
}
 
inline
const CMt_Base::C_Attlist::TUpdateFileHashesSearchPath& CMt_Base::C_Attlist::GetUpdateFileHashesSearchPath(void) const
{
    if (!CanGetUpdateFileHashesSearchPath()) {
        ThrowUnassigned(39);
    }
    return m_UpdateFileHashesSearchPath;
}
 
inline
void CMt_Base::C_Attlist::SetUpdateFileHashesSearchPath(const CMt_Base::C_Attlist::TUpdateFileHashesSearchPath& value)
{
    m_UpdateFileHashesSearchPath = value;
    m_set_State[2] |= 0xc000;
}
 
inline
void CMt_Base::C_Attlist::SetUpdateFileHashesSearchPath(CMt_Base::C_Attlist::TUpdateFileHashesSearchPath&& value)
{
    m_UpdateFileHashesSearchPath = std::forward<CMt_Base::C_Attlist::TUpdateFileHashesSearchPath>(value);
    m_set_State[2] |= 0xc000;
}
 
inline
CMt_Base::C_Attlist::TUpdateFileHashesSearchPath& CMt_Base::C_Attlist::SetUpdateFileHashesSearchPath(void)
{
#ifdef _DEBUG
    if (!IsSetUpdateFileHashesSearchPath()) {
        m_UpdateFileHashesSearchPath = UnassignedString();
    }
#endif
    m_set_State[2] |= 0x4000;
    return m_UpdateFileHashesSearchPath;
}
 
inline
bool CMt_Base::C_Attlist::IsSetVerboseOutput(void) const
{
    return ((m_set_State[2] & 0x30000) != 0);
}
 
inline
bool CMt_Base::C_Attlist::CanGetVerboseOutput(void) const
{
    return IsSetVerboseOutput();
}
 
inline
const CMt_Base::C_Attlist::TVerboseOutput& CMt_Base::C_Attlist::GetVerboseOutput(void) const
{
    if (!CanGetVerboseOutput()) {
        ThrowUnassigned(40);
    }
    return m_VerboseOutput;
}
 
inline
void CMt_Base::C_Attlist::SetVerboseOutput(const CMt_Base::C_Attlist::TVerboseOutput& value)
{
    m_VerboseOutput = value;
    m_set_State[2] |= 0x30000;
}
 
inline
void CMt_Base::C_Attlist::SetVerboseOutput(CMt_Base::C_Attlist::TVerboseOutput&& value)
{
    m_VerboseOutput = std::forward<CMt_Base::C_Attlist::TVerboseOutput>(value);
    m_set_State[2] |= 0x30000;
}
 
inline
CMt_Base::C_Attlist::TVerboseOutput& CMt_Base::C_Attlist::SetVerboseOutput(void)
{
#ifdef _DEBUG
    if (!IsSetVerboseOutput()) {
        m_VerboseOutput = UnassignedString();
    }
#endif
    m_set_State[2] |= 0x10000;
    return m_VerboseOutput;
}
 
inline
CMt_Base::C_Mt::C_Mt(void)
{
}
 
inline
bool CMt_Base::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CMt_Base::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CMt_Base::TAttlist& CMt_Base::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<CMt_Base*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CMt_Base::TAttlist& CMt_Base::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CMt_Base::IsSetMt(void) const
{
    return m_Mt.NotEmpty();
}
 
inline
bool CMt_Base::CanGetMt(void) const
{
    return true;
}
 
inline
const CMt_Base::TMt& CMt_Base::GetMt(void) const
{
    if ( !m_Mt ) {
        const_cast<CMt_Base*>(this)->ResetMt();
    }
    return (*m_Mt);
}
 
inline
CMt_Base::TMt& CMt_Base::SetMt(void)
{
    if ( !m_Mt ) {
        ResetMt();
    }
    return (*m_Mt);
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_msbuild_SCOPE // namespace msbuild::
 
 
#endif // msbuild__BUILD_SYSTEM_PROJECT_TREE_BUILDER_MSBUILD_MT_BASE_HPP