ClCompile_.cpp

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 Description:
 *   This code was generated by application DATATOOL
 *   using the following specifications:
 *   'msbuild_dataobj.xsd'.
 *
 * ATTENTION:
 *   Don't edit or commit this file into CVS as this file will
 *   be overridden (by DATATOOL) without warning!
 * ===========================================================================
 */
 
// standard includes
#include <ncbi_pch.hpp>
#include <serial/serialimpl.hpp>
 
// generated includes
#include <build-system/project_tree_builder/msbuild/ClCompile.hpp>
BEGIN_msbuild_SCOPE // namespace msbuild::
 
 
// generated classes
 
void CClCompile_Base::C_Attlist::ResetCondition(void)
{
    m_Condition.erase();
    m_set_State[0] &= ~0x3;
}
 
void CClCompile_Base::C_Attlist::ResetInclude(void)
{
    m_Include.erase();
    m_set_State[0] &= ~0xc;
}
 
void CClCompile_Base::C_Attlist::ResetExclude(void)
{
    m_Exclude.erase();
    m_set_State[0] &= ~0x30;
}
 
void CClCompile_Base::C_Attlist::ResetRemove(void)
{
    m_Remove.erase();
    m_set_State[0] &= ~0xc0;
}
 
void CClCompile_Base::C_Attlist::ResetLabel(void)
{
    m_Label.erase();
    m_set_State[0] &= ~0x300;
}
 
void CClCompile_Base::C_Attlist::Reset(void)
{
    ResetCondition();
    ResetInclude();
    ResetExclude();
    ResetRemove();
    ResetLabel();
}
 
BEGIN_NAMED_CLASS_INFO("", CClCompile_Base::C_Attlist)
{
    SET_INTERNAL_NAME("ClCompile", "Attlist");
    SET_CLASS_MODULE("msbuild_dataobj");
    ADD_NAMED_STD_MEMBER("Condition", m_Condition)->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetOptional()->SetNsQualified(false);
    ADD_NAMED_STD_MEMBER("Include", m_Include)->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetOptional()->SetNsQualified(false);
    ADD_NAMED_STD_MEMBER("Exclude", m_Exclude)->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetOptional()->SetNsQualified(false);
    ADD_NAMED_STD_MEMBER("Remove", m_Remove)->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetOptional()->SetNsQualified(false);
    ADD_NAMED_STD_MEMBER("Label", m_Label)->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetOptional()->SetNsQualified(false);
    info->SetRandomOrder(true);
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CClCompile_Base::C_Attlist::C_Attlist(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
}
 
// destructor
CClCompile_Base::C_Attlist::~C_Attlist(void)
{
}
 
 
void CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::C_Attlist::ResetCondition(void)
{
    m_Condition.erase();
    m_set_State[0] &= ~0x3;
}
 
void CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::C_Attlist::Reset(void)
{
    ResetCondition();
}
 
BEGIN_NAMED_CLASS_INFO("", CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::C_Attlist)
{
    SET_INTERNAL_NAME("ClCompile.ClCompile.E.PrecompiledHeader", "Attlist");
    SET_CLASS_MODULE("msbuild_dataobj");
    ADD_NAMED_STD_MEMBER("Condition", m_Condition)->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetOptional()->SetNsQualified(false);
    info->SetRandomOrder(true);
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::C_Attlist::C_Attlist(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
}
 
// destructor
CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::C_Attlist::~C_Attlist(void)
{
}
 
 
void CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::ResetAttlist(void)
{
    if ( !m_Attlist ) {
        m_Attlist.Reset(new TAttlist());
        return;
    }
    (*m_Attlist).Reset();
}
 
void CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::SetAttlist(CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::TAttlist& value)
{
    m_Attlist.Reset(&value);
}
 
void CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::ResetPrecompiledHeader(void)
{
    m_PrecompiledHeader.erase();
    m_set_State[0] &= ~0xc;
}
 
void CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::Reset(void)
{
    ResetAttlist();
    ResetPrecompiledHeader();
}
 
BEGIN_NAMED_CLASS_INFO("PrecompiledHeader", CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader)
{
    SET_CLASS_MODULE("msbuild_dataobj");
    SET_NAMESPACE("http://schemas.microsoft.com/developer/msbuild/2003")->SetNsQualified(true);
    ADD_NAMED_REF_MEMBER("Attlist", m_Attlist, C_Attlist)->SetAttlist();
    ADD_NAMED_STD_MEMBER("PrecompiledHeader", m_PrecompiledHeader)->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetNotag();
    info->RandomOrder();
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::C_PrecompiledHeader(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetAttlist();
    }
}
 
// destructor
CClCompile_Base::C_E_ClCompile::C_PrecompiledHeader::~C_PrecompiledHeader(void)
{
}
 
 
void CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::C_Attlist::ResetCondition(void)
{
    m_Condition.erase();
    m_set_State[0] &= ~0x3;
}
 
void CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::C_Attlist::Reset(void)
{
    ResetCondition();
}
 
BEGIN_NAMED_CLASS_INFO("", CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::C_Attlist)
{
    SET_INTERNAL_NAME("ClCompile.ClCompile.E.CompileAsManaged", "Attlist");
    SET_CLASS_MODULE("msbuild_dataobj");
    ADD_NAMED_STD_MEMBER("Condition", m_Condition)->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetOptional()->SetNsQualified(false);
    info->SetRandomOrder(true);
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::C_Attlist::C_Attlist(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
}
 
// destructor
CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::C_Attlist::~C_Attlist(void)
{
}
 
 
void CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::ResetAttlist(void)
{
    if ( !m_Attlist ) {
        m_Attlist.Reset(new TAttlist());
        return;
    }
    (*m_Attlist).Reset();
}
 
void CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::SetAttlist(CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::TAttlist& value)
{
    m_Attlist.Reset(&value);
}
 
void CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::ResetCompileAsManaged(void)
{
    m_CompileAsManaged.erase();
    m_set_State[0] &= ~0xc;
}
 
void CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::Reset(void)
{
    ResetAttlist();
    ResetCompileAsManaged();
}
 
BEGIN_NAMED_CLASS_INFO("CompileAsManaged", CClCompile_Base::C_E_ClCompile::C_CompileAsManaged)
{
    SET_CLASS_MODULE("msbuild_dataobj");
    SET_NAMESPACE("http://schemas.microsoft.com/developer/msbuild/2003")->SetNsQualified(true);
    ADD_NAMED_REF_MEMBER("Attlist", m_Attlist, C_Attlist)->SetAttlist();
    ADD_NAMED_STD_MEMBER("CompileAsManaged", m_CompileAsManaged)->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetNotag();
    info->RandomOrder();
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::C_CompileAsManaged(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetAttlist();
    }
}
 
// destructor
CClCompile_Base::C_E_ClCompile::C_CompileAsManaged::~C_CompileAsManaged(void)
{
}
 
 
void CClCompile_Base::C_E_ClCompile::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CClCompile_Base::C_E_ClCompile::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_AdditionalIncludeDirectories:
    case e_AdditionalUsingDirectories:
    case e_ErrorReporting:
    case e_WarningLevel:
    case e_MinimalRebuild:
    case e_DebugInformationFormat:
    case e_PreprocessorDefinitions:
    case e_Optimization:
    case e_BasicRuntimeChecks:
    case e_RuntimeLibrary:
    case e_FunctionLevelLinking:
    case e_FloatingPointModel_:
    case e_IntrinsicFunctions:
    case e_PrecompiledHeaderFile:
    case e_MultiProcessorCompilation:
    case e_UseUnicodeForAssemblerListing:
    case e_UndefinePreprocessorDefinitions:
    case e_StringPooling:
    case e_BrowseInformation:
    case e_FloatingPointExceptions:
    case e_CreateHotpatchableImage:
    case e_RuntimeTypeInfo:
    case e_OpenMPSupport:
    case e_CallingConvention:
    case e_DisableSpecificWarnings:
    case e_ForcedIncludeFiles:
    case e_ForcedUsingFiles:
    case e_ShowIncludes:
    case e_UseFullPaths:
    case e_OmitDefaultLibName:
    case e_TreatSpecificWarningsAsErrors:
        m_string.Destruct();
        break;
    case e_PrecompiledHeader:
    case e_CompileAsManaged:
    case e_AnyContent:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CClCompile_Base::C_E_ClCompile::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_PrecompiledHeader:
        (m_object = new(pool) C_PrecompiledHeader())->AddReference();
        break;
    case e_CompileAsManaged:
        (m_object = new(pool) C_CompileAsManaged())->AddReference();
        break;
    case e_AnyContent:
        (m_object = new(pool) ncbi::CAnyContentObject())->AddReference();
        break;
    case e_AdditionalIncludeDirectories:
    case e_AdditionalUsingDirectories:
    case e_ErrorReporting:
    case e_WarningLevel:
    case e_MinimalRebuild:
    case e_DebugInformationFormat:
    case e_PreprocessorDefinitions:
    case e_Optimization:
    case e_BasicRuntimeChecks:
    case e_RuntimeLibrary:
    case e_FunctionLevelLinking:
    case e_FloatingPointModel_:
    case e_IntrinsicFunctions:
    case e_PrecompiledHeaderFile:
    case e_MultiProcessorCompilation:
    case e_UseUnicodeForAssemblerListing:
    case e_UndefinePreprocessorDefinitions:
    case e_StringPooling:
    case e_BrowseInformation:
    case e_FloatingPointExceptions:
    case e_CreateHotpatchableImage:
    case e_RuntimeTypeInfo:
    case e_OpenMPSupport:
    case e_CallingConvention:
    case e_DisableSpecificWarnings:
    case e_ForcedIncludeFiles:
    case e_ForcedUsingFiles:
    case e_ShowIncludes:
    case e_UseFullPaths:
    case e_OmitDefaultLibName:
    case e_TreatSpecificWarningsAsErrors:
        m_string.Construct();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CClCompile_Base::C_E_ClCompile::sm_SelectionNames[] = {
    "not set",
    "PrecompiledHeader",
    "AdditionalIncludeDirectories",
    "AdditionalUsingDirectories",
    "CompileAsManaged",
    "ErrorReporting",
    "WarningLevel",
    "MinimalRebuild",
    "DebugInformationFormat",
    "PreprocessorDefinitions",
    "Optimization",
    "BasicRuntimeChecks",
    "RuntimeLibrary",
    "FunctionLevelLinking",
    "FloatingPointModel ",
    "IntrinsicFunctions",
    "PrecompiledHeaderFile",
    "MultiProcessorCompilation",
    "UseUnicodeForAssemblerListing",
    "UndefinePreprocessorDefinitions",
    "StringPooling",
    "BrowseInformation",
    "FloatingPointExceptions",
    "CreateHotpatchableImage",
    "RuntimeTypeInfo",
    "OpenMPSupport",
    "CallingConvention",
    "DisableSpecificWarnings",
    "ForcedIncludeFiles",
    "ForcedUsingFiles",
    "ShowIncludes",
    "UseFullPaths",
    "OmitDefaultLibName",
    "TreatSpecificWarningsAsErrors",
    "AnyContent"
};
 
NCBI_NS_STD::string CClCompile_Base::C_E_ClCompile::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CClCompile_Base::C_E_ClCompile::ThrowInvalidSelection(E_Choice index) const
{
    throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
const CClCompile_Base::C_E_ClCompile::TPrecompiledHeader& CClCompile_Base::C_E_ClCompile::GetPrecompiledHeader(void) const
{
    CheckSelected(e_PrecompiledHeader);
    return *static_cast<const TPrecompiledHeader*>(m_object);
}
 
CClCompile_Base::C_E_ClCompile::TPrecompiledHeader& CClCompile_Base::C_E_ClCompile::SetPrecompiledHeader(void)
{
    Select(e_PrecompiledHeader, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TPrecompiledHeader*>(m_object);
}
 
void CClCompile_Base::C_E_ClCompile::SetPrecompiledHeader(CClCompile_Base::C_E_ClCompile::TPrecompiledHeader& value)
{
    TPrecompiledHeader* ptr = &value;
    if ( m_choice != e_PrecompiledHeader || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_PrecompiledHeader;
    }
}
 
void CClCompile_Base::C_E_ClCompile::SetAdditionalIncludeDirectories(const CClCompile_Base::C_E_ClCompile::TAdditionalIncludeDirectories& value)
{
    Select(e_AdditionalIncludeDirectories, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetAdditionalUsingDirectories(const CClCompile_Base::C_E_ClCompile::TAdditionalUsingDirectories& value)
{
    Select(e_AdditionalUsingDirectories, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
const CClCompile_Base::C_E_ClCompile::TCompileAsManaged& CClCompile_Base::C_E_ClCompile::GetCompileAsManaged(void) const
{
    CheckSelected(e_CompileAsManaged);
    return *static_cast<const TCompileAsManaged*>(m_object);
}
 
CClCompile_Base::C_E_ClCompile::TCompileAsManaged& CClCompile_Base::C_E_ClCompile::SetCompileAsManaged(void)
{
    Select(e_CompileAsManaged, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCompileAsManaged*>(m_object);
}
 
void CClCompile_Base::C_E_ClCompile::SetCompileAsManaged(CClCompile_Base::C_E_ClCompile::TCompileAsManaged& value)
{
    TCompileAsManaged* ptr = &value;
    if ( m_choice != e_CompileAsManaged || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_CompileAsManaged;
    }
}
 
void CClCompile_Base::C_E_ClCompile::SetErrorReporting(const CClCompile_Base::C_E_ClCompile::TErrorReporting& value)
{
    Select(e_ErrorReporting, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetWarningLevel(const CClCompile_Base::C_E_ClCompile::TWarningLevel& value)
{
    Select(e_WarningLevel, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetMinimalRebuild(const CClCompile_Base::C_E_ClCompile::TMinimalRebuild& value)
{
    Select(e_MinimalRebuild, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetDebugInformationFormat(const CClCompile_Base::C_E_ClCompile::TDebugInformationFormat& value)
{
    Select(e_DebugInformationFormat, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetPreprocessorDefinitions(const CClCompile_Base::C_E_ClCompile::TPreprocessorDefinitions& value)
{
    Select(e_PreprocessorDefinitions, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetOptimization(const CClCompile_Base::C_E_ClCompile::TOptimization& value)
{
    Select(e_Optimization, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetBasicRuntimeChecks(const CClCompile_Base::C_E_ClCompile::TBasicRuntimeChecks& value)
{
    Select(e_BasicRuntimeChecks, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetRuntimeLibrary(const CClCompile_Base::C_E_ClCompile::TRuntimeLibrary& value)
{
    Select(e_RuntimeLibrary, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetFunctionLevelLinking(const CClCompile_Base::C_E_ClCompile::TFunctionLevelLinking& value)
{
    Select(e_FunctionLevelLinking, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetFloatingPointModel_(const CClCompile_Base::C_E_ClCompile::TFloatingPointModel_& value)
{
    Select(e_FloatingPointModel_, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetIntrinsicFunctions(const CClCompile_Base::C_E_ClCompile::TIntrinsicFunctions& value)
{
    Select(e_IntrinsicFunctions, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetPrecompiledHeaderFile(const CClCompile_Base::C_E_ClCompile::TPrecompiledHeaderFile& value)
{
    Select(e_PrecompiledHeaderFile, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetMultiProcessorCompilation(const CClCompile_Base::C_E_ClCompile::TMultiProcessorCompilation& value)
{
    Select(e_MultiProcessorCompilation, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetUseUnicodeForAssemblerListing(const CClCompile_Base::C_E_ClCompile::TUseUnicodeForAssemblerListing& value)
{
    Select(e_UseUnicodeForAssemblerListing, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetUndefinePreprocessorDefinitions(const CClCompile_Base::C_E_ClCompile::TUndefinePreprocessorDefinitions& value)
{
    Select(e_UndefinePreprocessorDefinitions, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetStringPooling(const CClCompile_Base::C_E_ClCompile::TStringPooling& value)
{
    Select(e_StringPooling, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetBrowseInformation(const CClCompile_Base::C_E_ClCompile::TBrowseInformation& value)
{
    Select(e_BrowseInformation, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetFloatingPointExceptions(const CClCompile_Base::C_E_ClCompile::TFloatingPointExceptions& value)
{
    Select(e_FloatingPointExceptions, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetCreateHotpatchableImage(const CClCompile_Base::C_E_ClCompile::TCreateHotpatchableImage& value)
{
    Select(e_CreateHotpatchableImage, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetRuntimeTypeInfo(const CClCompile_Base::C_E_ClCompile::TRuntimeTypeInfo& value)
{
    Select(e_RuntimeTypeInfo, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetOpenMPSupport(const CClCompile_Base::C_E_ClCompile::TOpenMPSupport& value)
{
    Select(e_OpenMPSupport, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetCallingConvention(const CClCompile_Base::C_E_ClCompile::TCallingConvention& value)
{
    Select(e_CallingConvention, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetDisableSpecificWarnings(const CClCompile_Base::C_E_ClCompile::TDisableSpecificWarnings& value)
{
    Select(e_DisableSpecificWarnings, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetForcedIncludeFiles(const CClCompile_Base::C_E_ClCompile::TForcedIncludeFiles& value)
{
    Select(e_ForcedIncludeFiles, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetForcedUsingFiles(const CClCompile_Base::C_E_ClCompile::TForcedUsingFiles& value)
{
    Select(e_ForcedUsingFiles, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetShowIncludes(const CClCompile_Base::C_E_ClCompile::TShowIncludes& value)
{
    Select(e_ShowIncludes, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetUseFullPaths(const CClCompile_Base::C_E_ClCompile::TUseFullPaths& value)
{
    Select(e_UseFullPaths, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetOmitDefaultLibName(const CClCompile_Base::C_E_ClCompile::TOmitDefaultLibName& value)
{
    Select(e_OmitDefaultLibName, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
void CClCompile_Base::C_E_ClCompile::SetTreatSpecificWarningsAsErrors(const CClCompile_Base::C_E_ClCompile::TTreatSpecificWarningsAsErrors& value)
{
    Select(e_TreatSpecificWarningsAsErrors, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
const CClCompile_Base::C_E_ClCompile::TAnyContent& CClCompile_Base::C_E_ClCompile::GetAnyContent(void) const
{
    CheckSelected(e_AnyContent);
    return *static_cast<const TAnyContent*>(m_object);
}
 
CClCompile_Base::C_E_ClCompile::TAnyContent& CClCompile_Base::C_E_ClCompile::SetAnyContent(void)
{
    Select(e_AnyContent, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TAnyContent*>(m_object);
}
 
void CClCompile_Base::C_E_ClCompile::SetAnyContent(CClCompile_Base::C_E_ClCompile::TAnyContent& value)
{
    TAnyContent* ptr = &value;
    if ( m_choice != e_AnyContent || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_AnyContent;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CClCompile_Base::C_E_ClCompile)
{
    SET_INTERNAL_NAME("ClCompile.ClCompile", "E");
    SET_CHOICE_MODULE("msbuild_dataobj");
    SET_NAMESPACE("http://schemas.microsoft.com/developer/msbuild/2003")->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("PrecompiledHeader", m_object, C_PrecompiledHeader)->SetOptional();
    ADD_NAMED_BUF_CHOICE_VARIANT("AdditionalIncludeDirectories", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("AdditionalUsingDirectories", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_REF_CHOICE_VARIANT("CompileAsManaged", m_object, C_CompileAsManaged);
    ADD_NAMED_BUF_CHOICE_VARIANT("ErrorReporting", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("WarningLevel", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("MinimalRebuild", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("DebugInformationFormat", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("PreprocessorDefinitions", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("Optimization", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("BasicRuntimeChecks", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("RuntimeLibrary", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("FunctionLevelLinking", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("FloatingPointModel ", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("IntrinsicFunctions", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("PrecompiledHeaderFile", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("MultiProcessorCompilation", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("UseUnicodeForAssemblerListing", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("UndefinePreprocessorDefinitions", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("StringPooling", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("BrowseInformation", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("FloatingPointExceptions", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("CreateHotpatchableImage", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("RuntimeTypeInfo", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("OpenMPSupport", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("CallingConvention", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("DisableSpecificWarnings", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("ForcedIncludeFiles", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("ForcedUsingFiles", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("ShowIncludes", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("UseFullPaths", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("OmitDefaultLibName", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_BUF_CHOICE_VARIANT("TreatSpecificWarningsAsErrors", m_string, STD, (NCBI_NS_STD::string));
    ADD_NAMED_REF_CHOICE_VARIANT("AnyContent", m_object, NCBI_NS_NCBI::CAnyContentObject)->SetNotag();
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CClCompile_Base::C_E_ClCompile::C_E_ClCompile(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CClCompile_Base::C_E_ClCompile::~C_E_ClCompile(void)
{
    Reset();
}
 
 
void CClCompile_Base::ResetAttlist(void)
{
    if ( !m_Attlist ) {
        m_Attlist.Reset(new TAttlist());
        return;
    }
    (*m_Attlist).Reset();
}
 
void CClCompile_Base::SetAttlist(CClCompile_Base::TAttlist& value)
{
    m_Attlist.Reset(&value);
}
 
void CClCompile_Base::ResetClCompile(void)
{
    m_ClCompile.clear();
    m_set_State[0] &= ~0xc;
}
 
void CClCompile_Base::Reset(void)
{
    ResetAttlist();
    ResetClCompile();
}
 
BEGIN_NAMED_BASE_CLASS_INFO("ClCompile", CClCompile)
{
    SET_CLASS_MODULE("msbuild_dataobj");
    SET_NAMESPACE("http://schemas.microsoft.com/developer/msbuild/2003")->SetNsQualified(true);
    ADD_NAMED_REF_MEMBER("Attlist", m_Attlist, C_Attlist)->SetAttlist();
    ADD_NAMED_MEMBER("ClCompile", m_ClCompile, STL_list, (STL_CRef, (CLASS, (C_E_ClCompile))))->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetOptional()->SetNotag();
    info->RandomOrder();
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CClCompile_Base::CClCompile_Base(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetAttlist();
    }
}
 
// destructor
CClCompile_Base::~CClCompile_Base(void)
{
}
 
 
 
END_msbuild_SCOPE // namespace msbuild::