TargetType_.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 TargetType_.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_TARGETTYPE_BASE_HPP
#define msbuild__BUILD_SYSTEM_PROJECT_TREE_BUILDER_MSBUILD_TARGETTYPE_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
 
// generated includes
#include <list>
#include <string>
 
#ifndef BEGIN_msbuild_SCOPE
#  define BEGIN_msbuild_SCOPE BEGIN_SCOPE(msbuild)
#  define END_msbuild_SCOPE END_SCOPE(msbuild)
#endif
BEGIN_msbuild_SCOPE // namespace msbuild::
 
 
// forward declarations
class CItemGroup;
class COnError;
class CPropertyGroup;
class CTask;
 
 
// generated classes
 
 
/** @addtogroup dataspec_msbuild_dataobj
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///Groups tasks into a section of the build process
///
/// CTargetType_Base --
///
 
class CTargetType_Base : public NCBI_NS_NCBI::CSerialObject
{
    typedef NCBI_NS_NCBI::CSerialObject Tparent;
public:
    // constructor
    CTargetType_Base(void);
    // destructor
    virtual ~CTargetType_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 TName;
        typedef NCBI_NS_STD::string TDependsOnTargets;
        typedef NCBI_NS_STD::string TInputs;
        typedef NCBI_NS_STD::string TOutputs;
        typedef NCBI_NS_STD::string TCondition;
        typedef NCBI_NS_STD::string TKeepDuplicateOutputs;
        typedef NCBI_NS_STD::string TReturns;
        typedef NCBI_NS_STD::string TBeforeTargets;
        typedef NCBI_NS_STD::string TAfterTargets;
        typedef NCBI_NS_STD::string TLabel;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_Name,
            e_DependsOnTargets,
            e_Inputs,
            e_Outputs,
            e_Condition,
            e_KeepDuplicateOutputs,
            e_Returns,
            e_BeforeTargets,
            e_AfterTargets,
            e_Label
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 11> TmemberIndex;
    
        // getters
        // setters
    
        /// no elements are allowed under Target after an OnError element 
        ///Name of the target
        /// Check if a value has been assigned to Name data member.
        ///
        /// Data member Name is mandatory;
        /// its type is defined as 'typedef NCBI_NS_STD::string TName'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetName(void) const;
    
        /// Check if it is safe to call GetName method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetName(void) const;
    
        /// Reset Name data member.
        void ResetName(void);
    
        /// Get the Name member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TName& GetName(void) const;
    
        /// Assign a value to Name data member.
        ///
        /// @param value
        ///   Value to assign
        void SetName(const TName& value);
        void SetName(TName&& value);
    
        /// Assign a value to Name data member.
        ///
        /// @return
        ///   Reference to the data value.
        TName& SetName(void);
    
        ///Optional semi-colon separated list of targets that should be run before this target
        /// Check if a value has been assigned to DependsOnTargets data member.
        ///
        /// Data member DependsOnTargets is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TDependsOnTargets'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetDependsOnTargets(void) const;
    
        /// Check if it is safe to call GetDependsOnTargets method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetDependsOnTargets(void) const;
    
        /// Reset DependsOnTargets data member.
        void ResetDependsOnTargets(void);
    
        /// Get the DependsOnTargets member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TDependsOnTargets& GetDependsOnTargets(void) const;
    
        /// Assign a value to DependsOnTargets data member.
        ///
        /// @param value
        ///   Value to assign
        void SetDependsOnTargets(const TDependsOnTargets& value);
        void SetDependsOnTargets(TDependsOnTargets&& value);
    
        /// Assign a value to DependsOnTargets data member.
        ///
        /// @return
        ///   Reference to the data value.
        TDependsOnTargets& SetDependsOnTargets(void);
    
        ///Optional semi-colon separated list of files that form inputs into this target. Their timestamps will be compared with the timestamps of files in Outputs to determine whether the Target is up to date
        /// Check if a value has been assigned to Inputs data member.
        ///
        /// Data member Inputs is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TInputs'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetInputs(void) const;
    
        /// Check if it is safe to call GetInputs method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetInputs(void) const;
    
        /// Reset Inputs data member.
        void ResetInputs(void);
    
        /// Get the Inputs member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TInputs& GetInputs(void) const;
    
        /// Assign a value to Inputs data member.
        ///
        /// @param value
        ///   Value to assign
        void SetInputs(const TInputs& value);
        void SetInputs(TInputs&& value);
    
        /// Assign a value to Inputs data member.
        ///
        /// @return
        ///   Reference to the data value.
        TInputs& SetInputs(void);
    
        ///Optional semi-colon separated list of files that form outputs into this target. Their timestamps will be compared with the timestamps of files in Inputs to determine whether the Target is up to date
        /// Check if a value has been assigned to Outputs data member.
        ///
        /// Data member Outputs is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TOutputs'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetOutputs(void) const;
    
        /// Check if it is safe to call GetOutputs method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetOutputs(void) const;
    
        /// Reset Outputs data member.
        void ResetOutputs(void);
    
        /// Get the Outputs member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TOutputs& GetOutputs(void) const;
    
        /// Assign a value to Outputs data member.
        ///
        /// @param value
        ///   Value to assign
        void SetOutputs(const TOutputs& value);
        void SetOutputs(TOutputs&& value);
    
        /// Assign a value to Outputs data member.
        ///
        /// @return
        ///   Reference to the data value.
        TOutputs& SetOutputs(void);
    
        ///Optional expression evaluated to determine whether the Target and the targets it depends on should be run
        /// Check if a value has been assigned to Condition data member.
        ///
        /// Data member Condition is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TCondition'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetCondition(void) const;
    
        /// Check if it is safe to call GetCondition method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetCondition(void) const;
    
        /// Reset Condition data member.
        void ResetCondition(void);
    
        /// Get the Condition member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TCondition& GetCondition(void) const;
    
        /// Assign a value to Condition data member.
        ///
        /// @param value
        ///   Value to assign
        void SetCondition(const TCondition& value);
        void SetCondition(TCondition&& value);
    
        /// Assign a value to Condition data member.
        ///
        /// @return
        ///   Reference to the data value.
        TCondition& SetCondition(void);
    
        ///Optional expression evaluated to determine whether duplicate items in the Target's Returns should be removed before returning them. The default is not to eliminate duplicates.
        /// Check if a value has been assigned to KeepDuplicateOutputs data member.
        ///
        /// Data member KeepDuplicateOutputs is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TKeepDuplicateOutputs'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetKeepDuplicateOutputs(void) const;
    
        /// Check if it is safe to call GetKeepDuplicateOutputs method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetKeepDuplicateOutputs(void) const;
    
        /// Reset KeepDuplicateOutputs data member.
        void ResetKeepDuplicateOutputs(void);
    
        /// Get the KeepDuplicateOutputs member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TKeepDuplicateOutputs& GetKeepDuplicateOutputs(void) const;
    
        /// Assign a value to KeepDuplicateOutputs data member.
        ///
        /// @param value
        ///   Value to assign
        void SetKeepDuplicateOutputs(const TKeepDuplicateOutputs& value);
        void SetKeepDuplicateOutputs(TKeepDuplicateOutputs&& value);
    
        /// Assign a value to KeepDuplicateOutputs data member.
        ///
        /// @return
        ///   Reference to the data value.
        TKeepDuplicateOutputs& SetKeepDuplicateOutputs(void);
    
        ///Optional expression evaluated to determine which items generated by the target should be returned by the target. If there are no Returns attributes on Targets in the file, the Outputs attributes are used instead for this purpose.
        /// Check if a value has been assigned to Returns data member.
        ///
        /// Data member Returns is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TReturns'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetReturns(void) const;
    
        /// Check if it is safe to call GetReturns method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetReturns(void) const;
    
        /// Reset Returns data member.
        void ResetReturns(void);
    
        /// Get the Returns member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TReturns& GetReturns(void) const;
    
        /// Assign a value to Returns data member.
        ///
        /// @param value
        ///   Value to assign
        void SetReturns(const TReturns& value);
        void SetReturns(TReturns&& value);
    
        /// Assign a value to Returns data member.
        ///
        /// @return
        ///   Reference to the data value.
        TReturns& SetReturns(void);
    
        ///Optional semi-colon separated list of targets that this target should run before.
        /// Check if a value has been assigned to BeforeTargets data member.
        ///
        /// Data member BeforeTargets is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TBeforeTargets'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetBeforeTargets(void) const;
    
        /// Check if it is safe to call GetBeforeTargets method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetBeforeTargets(void) const;
    
        /// Reset BeforeTargets data member.
        void ResetBeforeTargets(void);
    
        /// Get the BeforeTargets member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TBeforeTargets& GetBeforeTargets(void) const;
    
        /// Assign a value to BeforeTargets data member.
        ///
        /// @param value
        ///   Value to assign
        void SetBeforeTargets(const TBeforeTargets& value);
        void SetBeforeTargets(TBeforeTargets&& value);
    
        /// Assign a value to BeforeTargets data member.
        ///
        /// @return
        ///   Reference to the data value.
        TBeforeTargets& SetBeforeTargets(void);
    
        ///Optional semi-colon separated list of targets that this target should run after.
        /// Check if a value has been assigned to AfterTargets data member.
        ///
        /// Data member AfterTargets is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TAfterTargets'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAfterTargets(void) const;
    
        /// Check if it is safe to call GetAfterTargets method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAfterTargets(void) const;
    
        /// Reset AfterTargets data member.
        void ResetAfterTargets(void);
    
        /// Get the AfterTargets member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAfterTargets& GetAfterTargets(void) const;
    
        /// Assign a value to AfterTargets data member.
        ///
        /// @param value
        ///   Value to assign
        void SetAfterTargets(const TAfterTargets& value);
        void SetAfterTargets(TAfterTargets&& value);
    
        /// Assign a value to AfterTargets data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAfterTargets& SetAfterTargets(void);
    
        ///Optional expression. Used to identify or order system and user elements
        /// Check if a value has been assigned to Label data member.
        ///
        /// Data member Label is optional;
        /// its type is defined as 'typedef NCBI_NS_STD::string TLabel'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetLabel(void) const;
    
        /// Check if it is safe to call GetLabel method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetLabel(void) const;
    
        /// Reset Label data member.
        void ResetLabel(void);
    
        /// Get the Label member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TLabel& GetLabel(void) const;
    
        /// Assign a value to Label data member.
        ///
        /// @param value
        ///   Value to assign
        void SetLabel(const TLabel& value);
        void SetLabel(TLabel&& value);
    
        /// Assign a value to Label data member.
        ///
        /// @return
        ///   Reference to the data value.
        TLabel& SetLabel(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[1];
        NCBI_NS_STD::string m_Name;
        NCBI_NS_STD::string m_DependsOnTargets;
        NCBI_NS_STD::string m_Inputs;
        NCBI_NS_STD::string m_Outputs;
        NCBI_NS_STD::string m_Condition;
        NCBI_NS_STD::string m_KeepDuplicateOutputs;
        NCBI_NS_STD::string m_Returns;
        NCBI_NS_STD::string m_BeforeTargets;
        NCBI_NS_STD::string m_AfterTargets;
        NCBI_NS_STD::string m_Label;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_TPI --
    ///
    
    class C_TPI : public NCBI_NS_NCBI::CSerialObject
    {
        typedef NCBI_NS_NCBI::CSerialObject Tparent;
    public:
        // constructor
        C_TPI(void);
        // destructor
        ~C_TPI(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
    
        /// Choice variants.
        enum E_Choice {
            e_not_set = 0,    ///< No variant selected
            e_Task,
            e_PropertyGroup,
            e_ItemGroup
        };
        /// Maximum+1 value of the choice variant enumerator.
        enum E_ChoiceStopper {
            e_MaxChoice = 4 ///< == e_ItemGroup+1
        };
    
        /// Reset the whole object
        void Reset(void);
    
        /// Reset the selection (set it to e_not_set).
        void ResetSelection(void);
    
        /// Which variant is currently selected.
        ///
        /// @return
        ///   Choice state enumerator.
        E_Choice Which(void) const;
    
        /// Verify selection, throw exception if it differs from the expected.
        ///
        /// @param index
        ///   Expected selection.
        void CheckSelected(E_Choice index) const;
    
        /// Throw 'InvalidSelection' exception.
        ///
        /// @param index
        ///   Expected selection.
        NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
    
        /// Retrieve selection name (for diagnostic purposes).
        ///
        /// @param index
        ///   One of possible selection states.
        /// @return
        ///   Name string.
        static NCBI_NS_STD::string SelectionName(E_Choice index);
    
        /// Select the requested variant if needed.
        ///
        /// @param index
        ///   New selection state.
        /// @param reset
        ///   Flag that defines the resetting of the variant data. The data will
        ///   be reset if either the current selection differs from the new one,
        ///   or the flag is set to eDoResetVariant.
        void Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset = NCBI_NS_NCBI::eDoResetVariant);
        /// Select the requested variant if needed,
        /// allocating CObject variants from memory pool.
        void Select(E_Choice index,
                    NCBI_NS_NCBI::EResetVariant reset,
                    NCBI_NS_NCBI::CObjectMemoryPool* pool);
    
        // types
        typedef CTask TTask;
        typedef CPropertyGroup TPropertyGroup;
        typedef CItemGroup TItemGroup;
    
        // getters
        // setters
    
    
        /// Check if variant Task is selected.
        ///
        /// Task type is defined as 'typedef CTask TTask'.
        /// @return
        ///   - true, if the variant is selected.
        ///   - false, otherwise.
        bool IsTask(void) const;
    
        /// Get the variant data.
        ///
        /// @return
        ///   Reference to the data.
        const TTask& GetTask(void) const;
    
        /// Select the variant.
        ///
        /// @return
        ///   Reference to the variant data.
        TTask& SetTask(void);
        /// Select the variant and set its data.
        ///
        /// @param value
        ///   Reference to the data.
        void SetTask(TTask& value);
    
    
        /// Check if variant PropertyGroup is selected.
        ///
        /// PropertyGroup type is defined as 'typedef CPropertyGroup TPropertyGroup'.
        /// @return
        ///   - true, if the variant is selected.
        ///   - false, otherwise.
        bool IsPropertyGroup(void) const;
    
        /// Get the variant data.
        ///
        /// @return
        ///   Reference to the data.
        const TPropertyGroup& GetPropertyGroup(void) const;
    
        /// Select the variant.
        ///
        /// @return
        ///   Reference to the variant data.
        TPropertyGroup& SetPropertyGroup(void);
        /// Select the variant and set its data.
        ///
        /// @param value
        ///   Reference to the data.
        void SetPropertyGroup(TPropertyGroup& value);
    
    
        /// Check if variant ItemGroup is selected.
        ///
        /// ItemGroup type is defined as 'typedef CItemGroup TItemGroup'.
        /// @return
        ///   - true, if the variant is selected.
        ///   - false, otherwise.
        bool IsItemGroup(void) const;
    
        /// Get the variant data.
        ///
        /// @return
        ///   Reference to the data.
        const TItemGroup& GetItemGroup(void) const;
    
        /// Select the variant.
        ///
        /// @return
        ///   Reference to the variant data.
        TItemGroup& SetItemGroup(void);
        /// Select the variant and set its data.
        ///
        /// @param value
        ///   Reference to the data.
        void SetItemGroup(TItemGroup& value);
    
    
    private:
        // copy constructor and assignment operator
        C_TPI(const C_TPI& );
        C_TPI& operator=(const C_TPI& );
        // choice state
        E_Choice m_choice;
        // helper methods
        void DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool = 0);
    
        static const char* const sm_SelectionNames[];
        // data
        NCBI_NS_NCBI::CSerialObject *m_object;
    };
    // types
    typedef C_Attlist TAttlist;
    typedef C_TPI TTPI;
    typedef NCBI_NS_STD::list< NCBI_NS_NCBI::CRef< COnError > > TOnError;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_Attlist,
        e_TPI,
        e_OnError
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 4> 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 TPI data member.
    ///
    /// Data member TPI is mandatory;
    /// its type is defined as 'typedef C_TPI TTPI'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetTPI(void) const;
 
    /// Check if it is safe to call GetTPI method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetTPI(void) const;
 
    /// Reset TPI data member.
    void ResetTPI(void);
 
    /// Get the TPI member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TTPI& GetTPI(void) const;
 
    /// Assign a value to TPI data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetTPI(TTPI& value);
 
    /// Assign a value to TPI data member.
    ///
    /// @return
    ///   Reference to the data value.
    TTPI& SetTPI(void);
 
    /// Check if a value has been assigned to OnError data member.
    ///
    /// Data member OnError is optional;
    /// its type is defined as 'typedef NCBI_NS_STD::list< NCBI_NS_NCBI::CRef< COnError > > TOnError'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetOnError(void) const;
 
    /// Check if it is safe to call GetOnError method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetOnError(void) const;
 
    /// Reset OnError data member.
    void ResetOnError(void);
 
    /// Get the OnError member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TOnError& GetOnError(void) const;
 
    /// Assign a value to OnError data member.
    ///
    /// @return
    ///   Reference to the data value.
    TOnError& SetOnError(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CTargetType_Base(const CTargetType_Base&);
    CTargetType_Base& operator=(const CTargetType_Base&);
 
    // data
    Uint4 m_set_State[1];
    NCBI_NS_NCBI::CRef< TAttlist > m_Attlist;
    NCBI_NS_NCBI::CRef< TTPI > m_TPI;
    NCBI_NS_STD::list< NCBI_NS_NCBI::CRef< COnError > > m_OnError;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CTargetType_Base::C_Attlist::IsSetName(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetName(void) const
{
    return IsSetName();
}
 
inline
const CTargetType_Base::C_Attlist::TName& CTargetType_Base::C_Attlist::GetName(void) const
{
    if (!CanGetName()) {
        ThrowUnassigned(0);
    }
    return m_Name;
}
 
inline
void CTargetType_Base::C_Attlist::SetName(const CTargetType_Base::C_Attlist::TName& value)
{
    m_Name = value;
    m_set_State[0] |= 0x3;
}
 
inline
void CTargetType_Base::C_Attlist::SetName(CTargetType_Base::C_Attlist::TName&& value)
{
    m_Name = std::forward<CTargetType_Base::C_Attlist::TName>(value);
    m_set_State[0] |= 0x3;
}
 
inline
CTargetType_Base::C_Attlist::TName& CTargetType_Base::C_Attlist::SetName(void)
{
#ifdef _DEBUG
    if (!IsSetName()) {
        m_Name = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x1;
    return m_Name;
}
 
inline
bool CTargetType_Base::C_Attlist::IsSetDependsOnTargets(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetDependsOnTargets(void) const
{
    return IsSetDependsOnTargets();
}
 
inline
const CTargetType_Base::C_Attlist::TDependsOnTargets& CTargetType_Base::C_Attlist::GetDependsOnTargets(void) const
{
    if (!CanGetDependsOnTargets()) {
        ThrowUnassigned(1);
    }
    return m_DependsOnTargets;
}
 
inline
void CTargetType_Base::C_Attlist::SetDependsOnTargets(const CTargetType_Base::C_Attlist::TDependsOnTargets& value)
{
    m_DependsOnTargets = value;
    m_set_State[0] |= 0xc;
}
 
inline
void CTargetType_Base::C_Attlist::SetDependsOnTargets(CTargetType_Base::C_Attlist::TDependsOnTargets&& value)
{
    m_DependsOnTargets = std::forward<CTargetType_Base::C_Attlist::TDependsOnTargets>(value);
    m_set_State[0] |= 0xc;
}
 
inline
CTargetType_Base::C_Attlist::TDependsOnTargets& CTargetType_Base::C_Attlist::SetDependsOnTargets(void)
{
#ifdef _DEBUG
    if (!IsSetDependsOnTargets()) {
        m_DependsOnTargets = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4;
    return m_DependsOnTargets;
}
 
inline
bool CTargetType_Base::C_Attlist::IsSetInputs(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetInputs(void) const
{
    return IsSetInputs();
}
 
inline
const CTargetType_Base::C_Attlist::TInputs& CTargetType_Base::C_Attlist::GetInputs(void) const
{
    if (!CanGetInputs()) {
        ThrowUnassigned(2);
    }
    return m_Inputs;
}
 
inline
void CTargetType_Base::C_Attlist::SetInputs(const CTargetType_Base::C_Attlist::TInputs& value)
{
    m_Inputs = value;
    m_set_State[0] |= 0x30;
}
 
inline
void CTargetType_Base::C_Attlist::SetInputs(CTargetType_Base::C_Attlist::TInputs&& value)
{
    m_Inputs = std::forward<CTargetType_Base::C_Attlist::TInputs>(value);
    m_set_State[0] |= 0x30;
}
 
inline
CTargetType_Base::C_Attlist::TInputs& CTargetType_Base::C_Attlist::SetInputs(void)
{
#ifdef _DEBUG
    if (!IsSetInputs()) {
        m_Inputs = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10;
    return m_Inputs;
}
 
inline
bool CTargetType_Base::C_Attlist::IsSetOutputs(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetOutputs(void) const
{
    return IsSetOutputs();
}
 
inline
const CTargetType_Base::C_Attlist::TOutputs& CTargetType_Base::C_Attlist::GetOutputs(void) const
{
    if (!CanGetOutputs()) {
        ThrowUnassigned(3);
    }
    return m_Outputs;
}
 
inline
void CTargetType_Base::C_Attlist::SetOutputs(const CTargetType_Base::C_Attlist::TOutputs& value)
{
    m_Outputs = value;
    m_set_State[0] |= 0xc0;
}
 
inline
void CTargetType_Base::C_Attlist::SetOutputs(CTargetType_Base::C_Attlist::TOutputs&& value)
{
    m_Outputs = std::forward<CTargetType_Base::C_Attlist::TOutputs>(value);
    m_set_State[0] |= 0xc0;
}
 
inline
CTargetType_Base::C_Attlist::TOutputs& CTargetType_Base::C_Attlist::SetOutputs(void)
{
#ifdef _DEBUG
    if (!IsSetOutputs()) {
        m_Outputs = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x40;
    return m_Outputs;
}
 
inline
bool CTargetType_Base::C_Attlist::IsSetCondition(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetCondition(void) const
{
    return IsSetCondition();
}
 
inline
const CTargetType_Base::C_Attlist::TCondition& CTargetType_Base::C_Attlist::GetCondition(void) const
{
    if (!CanGetCondition()) {
        ThrowUnassigned(4);
    }
    return m_Condition;
}
 
inline
void CTargetType_Base::C_Attlist::SetCondition(const CTargetType_Base::C_Attlist::TCondition& value)
{
    m_Condition = value;
    m_set_State[0] |= 0x300;
}
 
inline
void CTargetType_Base::C_Attlist::SetCondition(CTargetType_Base::C_Attlist::TCondition&& value)
{
    m_Condition = std::forward<CTargetType_Base::C_Attlist::TCondition>(value);
    m_set_State[0] |= 0x300;
}
 
inline
CTargetType_Base::C_Attlist::TCondition& CTargetType_Base::C_Attlist::SetCondition(void)
{
#ifdef _DEBUG
    if (!IsSetCondition()) {
        m_Condition = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x100;
    return m_Condition;
}
 
inline
bool CTargetType_Base::C_Attlist::IsSetKeepDuplicateOutputs(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetKeepDuplicateOutputs(void) const
{
    return IsSetKeepDuplicateOutputs();
}
 
inline
const CTargetType_Base::C_Attlist::TKeepDuplicateOutputs& CTargetType_Base::C_Attlist::GetKeepDuplicateOutputs(void) const
{
    if (!CanGetKeepDuplicateOutputs()) {
        ThrowUnassigned(5);
    }
    return m_KeepDuplicateOutputs;
}
 
inline
void CTargetType_Base::C_Attlist::SetKeepDuplicateOutputs(const CTargetType_Base::C_Attlist::TKeepDuplicateOutputs& value)
{
    m_KeepDuplicateOutputs = value;
    m_set_State[0] |= 0xc00;
}
 
inline
void CTargetType_Base::C_Attlist::SetKeepDuplicateOutputs(CTargetType_Base::C_Attlist::TKeepDuplicateOutputs&& value)
{
    m_KeepDuplicateOutputs = std::forward<CTargetType_Base::C_Attlist::TKeepDuplicateOutputs>(value);
    m_set_State[0] |= 0xc00;
}
 
inline
CTargetType_Base::C_Attlist::TKeepDuplicateOutputs& CTargetType_Base::C_Attlist::SetKeepDuplicateOutputs(void)
{
#ifdef _DEBUG
    if (!IsSetKeepDuplicateOutputs()) {
        m_KeepDuplicateOutputs = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x400;
    return m_KeepDuplicateOutputs;
}
 
inline
bool CTargetType_Base::C_Attlist::IsSetReturns(void) const
{
    return ((m_set_State[0] & 0x3000) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetReturns(void) const
{
    return IsSetReturns();
}
 
inline
const CTargetType_Base::C_Attlist::TReturns& CTargetType_Base::C_Attlist::GetReturns(void) const
{
    if (!CanGetReturns()) {
        ThrowUnassigned(6);
    }
    return m_Returns;
}
 
inline
void CTargetType_Base::C_Attlist::SetReturns(const CTargetType_Base::C_Attlist::TReturns& value)
{
    m_Returns = value;
    m_set_State[0] |= 0x3000;
}
 
inline
void CTargetType_Base::C_Attlist::SetReturns(CTargetType_Base::C_Attlist::TReturns&& value)
{
    m_Returns = std::forward<CTargetType_Base::C_Attlist::TReturns>(value);
    m_set_State[0] |= 0x3000;
}
 
inline
CTargetType_Base::C_Attlist::TReturns& CTargetType_Base::C_Attlist::SetReturns(void)
{
#ifdef _DEBUG
    if (!IsSetReturns()) {
        m_Returns = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x1000;
    return m_Returns;
}
 
inline
bool CTargetType_Base::C_Attlist::IsSetBeforeTargets(void) const
{
    return ((m_set_State[0] & 0xc000) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetBeforeTargets(void) const
{
    return IsSetBeforeTargets();
}
 
inline
const CTargetType_Base::C_Attlist::TBeforeTargets& CTargetType_Base::C_Attlist::GetBeforeTargets(void) const
{
    if (!CanGetBeforeTargets()) {
        ThrowUnassigned(7);
    }
    return m_BeforeTargets;
}
 
inline
void CTargetType_Base::C_Attlist::SetBeforeTargets(const CTargetType_Base::C_Attlist::TBeforeTargets& value)
{
    m_BeforeTargets = value;
    m_set_State[0] |= 0xc000;
}
 
inline
void CTargetType_Base::C_Attlist::SetBeforeTargets(CTargetType_Base::C_Attlist::TBeforeTargets&& value)
{
    m_BeforeTargets = std::forward<CTargetType_Base::C_Attlist::TBeforeTargets>(value);
    m_set_State[0] |= 0xc000;
}
 
inline
CTargetType_Base::C_Attlist::TBeforeTargets& CTargetType_Base::C_Attlist::SetBeforeTargets(void)
{
#ifdef _DEBUG
    if (!IsSetBeforeTargets()) {
        m_BeforeTargets = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4000;
    return m_BeforeTargets;
}
 
inline
bool CTargetType_Base::C_Attlist::IsSetAfterTargets(void) const
{
    return ((m_set_State[0] & 0x30000) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetAfterTargets(void) const
{
    return IsSetAfterTargets();
}
 
inline
const CTargetType_Base::C_Attlist::TAfterTargets& CTargetType_Base::C_Attlist::GetAfterTargets(void) const
{
    if (!CanGetAfterTargets()) {
        ThrowUnassigned(8);
    }
    return m_AfterTargets;
}
 
inline
void CTargetType_Base::C_Attlist::SetAfterTargets(const CTargetType_Base::C_Attlist::TAfterTargets& value)
{
    m_AfterTargets = value;
    m_set_State[0] |= 0x30000;
}
 
inline
void CTargetType_Base::C_Attlist::SetAfterTargets(CTargetType_Base::C_Attlist::TAfterTargets&& value)
{
    m_AfterTargets = std::forward<CTargetType_Base::C_Attlist::TAfterTargets>(value);
    m_set_State[0] |= 0x30000;
}
 
inline
CTargetType_Base::C_Attlist::TAfterTargets& CTargetType_Base::C_Attlist::SetAfterTargets(void)
{
#ifdef _DEBUG
    if (!IsSetAfterTargets()) {
        m_AfterTargets = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10000;
    return m_AfterTargets;
}
 
inline
bool CTargetType_Base::C_Attlist::IsSetLabel(void) const
{
    return ((m_set_State[0] & 0xc0000) != 0);
}
 
inline
bool CTargetType_Base::C_Attlist::CanGetLabel(void) const
{
    return IsSetLabel();
}
 
inline
const CTargetType_Base::C_Attlist::TLabel& CTargetType_Base::C_Attlist::GetLabel(void) const
{
    if (!CanGetLabel()) {
        ThrowUnassigned(9);
    }
    return m_Label;
}
 
inline
void CTargetType_Base::C_Attlist::SetLabel(const CTargetType_Base::C_Attlist::TLabel& value)
{
    m_Label = value;
    m_set_State[0] |= 0xc0000;
}
 
inline
void CTargetType_Base::C_Attlist::SetLabel(CTargetType_Base::C_Attlist::TLabel&& value)
{
    m_Label = std::forward<CTargetType_Base::C_Attlist::TLabel>(value);
    m_set_State[0] |= 0xc0000;
}
 
inline
CTargetType_Base::C_Attlist::TLabel& CTargetType_Base::C_Attlist::SetLabel(void)
{
#ifdef _DEBUG
    if (!IsSetLabel()) {
        m_Label = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x40000;
    return m_Label;
}
 
inline
CTargetType_Base::C_TPI::E_Choice CTargetType_Base::C_TPI::Which(void) const
{
    return m_choice;
}
 
inline
void CTargetType_Base::C_TPI::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CTargetType_Base::C_TPI::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CTargetType_Base::C_TPI::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CTargetType_Base::C_TPI::IsTask(void) const
{
    return m_choice == e_Task;
}
 
inline
bool CTargetType_Base::C_TPI::IsPropertyGroup(void) const
{
    return m_choice == e_PropertyGroup;
}
 
inline
bool CTargetType_Base::C_TPI::IsItemGroup(void) const
{
    return m_choice == e_ItemGroup;
}
 
inline
bool CTargetType_Base::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CTargetType_Base::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CTargetType_Base::TAttlist& CTargetType_Base::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<CTargetType_Base*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CTargetType_Base::TAttlist& CTargetType_Base::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CTargetType_Base::IsSetTPI(void) const
{
    return m_TPI.NotEmpty();
}
 
inline
bool CTargetType_Base::CanGetTPI(void) const
{
    return true;
}
 
inline
const CTargetType_Base::TTPI& CTargetType_Base::GetTPI(void) const
{
    if ( !m_TPI ) {
        const_cast<CTargetType_Base*>(this)->ResetTPI();
    }
    return (*m_TPI);
}
 
inline
CTargetType_Base::TTPI& CTargetType_Base::SetTPI(void)
{
    if ( !m_TPI ) {
        ResetTPI();
    }
    return (*m_TPI);
}
 
inline
bool CTargetType_Base::IsSetOnError(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CTargetType_Base::CanGetOnError(void) const
{
    return true;
}
 
inline
const CTargetType_Base::TOnError& CTargetType_Base::GetOnError(void) const
{
    return m_OnError;
}
 
inline
CTargetType_Base::TOnError& CTargetType_Base::SetOnError(void)
{
    m_set_State[0] |= 0x10;
    return m_OnError;
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_msbuild_SCOPE // namespace msbuild::
 
 
#endif // msbuild__BUILD_SYSTEM_PROJECT_TREE_BUILDER_MSBUILD_TARGETTYPE_BASE_HPP