Comment_rule_.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 Comment_rule_.hpp
/// Data storage class.
///
/// This file was generated by application DATATOOL
/// using the following specifications:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/valid/valid.asn">valid.asn</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/valid/valid.def">valid.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJECTS_VALID_COMMENT_RULE_BASE_HPP
#define OBJECTS_VALID_COMMENT_RULE_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
 
// generated includes
#include <string>
 
BEGIN_NCBI_SCOPE
 
#ifndef BEGIN_objects_SCOPE
#  define BEGIN_objects_SCOPE BEGIN_SCOPE(objects)
#  define END_objects_SCOPE END_SCOPE(objects)
#endif
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// forward declarations
class CDependent_field_set;
class CField_set;
class CPhrase_list;
 
 
// generated classes
 
 
/** @addtogroup dataspec_NCBI_Structured_comment_validation
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///
/// CComment_rule_Base --
///
 
class NCBI_VALID_EXPORT CComment_rule_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CComment_rule_Base(void);
    // destructor
    virtual ~CComment_rule_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    // types
    typedef string TPrefix;
    typedef bool TUpdated;
    typedef CField_set TFields;
    typedef bool TRequire_order;
    typedef bool TAllow_unlisted;
    typedef CDependent_field_set TDependent_rules;
    typedef CPhrase_list TForbidden_phrases;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_prefix,
        e_updated,
        e_fields,
        e_require_order,
        e_allow_unlisted,
        e_dependent_rules,
        e_forbidden_phrases
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 8> TmemberIndex;
 
    // getters
    // setters
 
    /// Check if a value has been assigned to Prefix data member.
    ///
    /// Data member Prefix is mandatory;
    /// its type is defined as 'typedef string TPrefix'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPrefix(void) const;
 
    /// Check if it is safe to call GetPrefix method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPrefix(void) const;
 
    /// Reset Prefix data member.
    void ResetPrefix(void);
 
    /// Get the Prefix member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPrefix& GetPrefix(void) const;
 
    /// Assign a value to Prefix data member.
    ///
    /// @param value
    ///   Value to assign
    void SetPrefix(const TPrefix& value);
    void SetPrefix(TPrefix&& value);
 
    /// Assign a value to Prefix data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPrefix& SetPrefix(void);
 
    /// Check if a value has been assigned to Updated data member.
    ///
    /// Data member Updated is optional with default false;
    /// its type is defined as 'typedef bool TUpdated'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetUpdated(void) const;
 
    /// Check if it is safe to call GetUpdated method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetUpdated(void) const;
 
    /// Reset Updated data member.
    void ResetUpdated(void);
 
    /// Assign default value to Updated data member.
    void SetDefaultUpdated(void);
 
    /// Get the Updated member data.
    ///
    /// @return
    ///   Copy of the member data.
    TUpdated GetUpdated(void) const;
 
    /// Assign a value to Updated data member.
    ///
    /// @param value
    ///   Value to assign
    void SetUpdated(TUpdated value);
 
    /// Assign a value to Updated data member.
    ///
    /// @return
    ///   Reference to the data value.
    TUpdated& SetUpdated(void);
 
    /// Check if a value has been assigned to Fields data member.
    ///
    /// Data member Fields is mandatory;
    /// its type is defined as 'typedef CField_set TFields'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetFields(void) const;
 
    /// Check if it is safe to call GetFields method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetFields(void) const;
 
    /// Reset Fields data member.
    void ResetFields(void);
 
    /// Get the Fields member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TFields& GetFields(void) const;
 
    /// Assign a value to Fields data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetFields(TFields& value);
 
    /// Assign a value to Fields data member.
    ///
    /// @return
    ///   Reference to the data value.
    TFields& SetFields(void);
 
    /// Check if a value has been assigned to Require_order data member.
    ///
    /// Data member Require_order is optional with default true;
    /// its type is defined as 'typedef bool TRequire_order'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetRequire_order(void) const;
 
    /// Check if it is safe to call GetRequire_order method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetRequire_order(void) const;
 
    /// Reset Require_order data member.
    void ResetRequire_order(void);
 
    /// Assign default value to Require_order data member.
    void SetDefaultRequire_order(void);
 
    /// Get the Require_order member data.
    ///
    /// @return
    ///   Copy of the member data.
    TRequire_order GetRequire_order(void) const;
 
    /// Assign a value to Require_order data member.
    ///
    /// @param value
    ///   Value to assign
    void SetRequire_order(TRequire_order value);
 
    /// Assign a value to Require_order data member.
    ///
    /// @return
    ///   Reference to the data value.
    TRequire_order& SetRequire_order(void);
 
    /// Check if a value has been assigned to Allow_unlisted data member.
    ///
    /// Data member Allow_unlisted is optional with default false;
    /// its type is defined as 'typedef bool TAllow_unlisted'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetAllow_unlisted(void) const;
 
    /// Check if it is safe to call GetAllow_unlisted method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetAllow_unlisted(void) const;
 
    /// Reset Allow_unlisted data member.
    void ResetAllow_unlisted(void);
 
    /// Assign default value to Allow_unlisted data member.
    void SetDefaultAllow_unlisted(void);
 
    /// Get the Allow_unlisted member data.
    ///
    /// @return
    ///   Copy of the member data.
    TAllow_unlisted GetAllow_unlisted(void) const;
 
    /// Assign a value to Allow_unlisted data member.
    ///
    /// @param value
    ///   Value to assign
    void SetAllow_unlisted(TAllow_unlisted value);
 
    /// Assign a value to Allow_unlisted data member.
    ///
    /// @return
    ///   Reference to the data value.
    TAllow_unlisted& SetAllow_unlisted(void);
 
    /// Check if a value has been assigned to Dependent_rules data member.
    ///
    /// Data member Dependent_rules is optional;
    /// its type is defined as 'typedef CDependent_field_set TDependent_rules'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetDependent_rules(void) const;
 
    /// Check if it is safe to call GetDependent_rules method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetDependent_rules(void) const;
 
    /// Reset Dependent_rules data member.
    void ResetDependent_rules(void);
 
    /// Get the Dependent_rules member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TDependent_rules& GetDependent_rules(void) const;
 
    /// Assign a value to Dependent_rules data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetDependent_rules(TDependent_rules& value);
 
    /// Assign a value to Dependent_rules data member.
    ///
    /// @return
    ///   Reference to the data value.
    TDependent_rules& SetDependent_rules(void);
 
    /// Check if a value has been assigned to Forbidden_phrases data member.
    ///
    /// Data member Forbidden_phrases is optional;
    /// its type is defined as 'typedef CPhrase_list TForbidden_phrases'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetForbidden_phrases(void) const;
 
    /// Check if it is safe to call GetForbidden_phrases method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetForbidden_phrases(void) const;
 
    /// Reset Forbidden_phrases data member.
    void ResetForbidden_phrases(void);
 
    /// Get the Forbidden_phrases member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TForbidden_phrases& GetForbidden_phrases(void) const;
 
    /// Assign a value to Forbidden_phrases data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetForbidden_phrases(TForbidden_phrases& value);
 
    /// Assign a value to Forbidden_phrases data member.
    ///
    /// @return
    ///   Reference to the data value.
    TForbidden_phrases& SetForbidden_phrases(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CComment_rule_Base(const CComment_rule_Base&);
    CComment_rule_Base& operator=(const CComment_rule_Base&);
 
    // data
    Uint4 m_set_State[1];
    string m_Prefix;
    bool m_Updated;
    CRef< TFields > m_Fields;
    bool m_Require_order;
    bool m_Allow_unlisted;
    CRef< TDependent_rules > m_Dependent_rules;
    CRef< TForbidden_phrases > m_Forbidden_phrases;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CComment_rule_Base::IsSetPrefix(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CComment_rule_Base::CanGetPrefix(void) const
{
    return IsSetPrefix();
}
 
inline
const CComment_rule_Base::TPrefix& CComment_rule_Base::GetPrefix(void) const
{
    if (!CanGetPrefix()) {
        ThrowUnassigned(0);
    }
    return m_Prefix;
}
 
inline
void CComment_rule_Base::SetPrefix(const CComment_rule_Base::TPrefix& value)
{
    m_Prefix = value;
    m_set_State[0] |= 0x3;
}
 
inline
void CComment_rule_Base::SetPrefix(CComment_rule_Base::TPrefix&& value)
{
    m_Prefix = std::forward<CComment_rule_Base::TPrefix>(value);
    m_set_State[0] |= 0x3;
}
 
inline
CComment_rule_Base::TPrefix& CComment_rule_Base::SetPrefix(void)
{
#ifdef _DEBUG
    if (!IsSetPrefix()) {
        m_Prefix = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x1;
    return m_Prefix;
}
 
inline
bool CComment_rule_Base::IsSetUpdated(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CComment_rule_Base::CanGetUpdated(void) const
{
    return true;
}
 
inline
void CComment_rule_Base::ResetUpdated(void)
{
    m_Updated = false;
    m_set_State[0] &= ~0xc;
}
 
inline
void CComment_rule_Base::SetDefaultUpdated(void)
{
    ResetUpdated();
}
 
inline
CComment_rule_Base::TUpdated CComment_rule_Base::GetUpdated(void) const
{
    return m_Updated;
}
 
inline
void CComment_rule_Base::SetUpdated(CComment_rule_Base::TUpdated value)
{
    m_Updated = value;
    m_set_State[0] |= 0xc;
}
 
inline
CComment_rule_Base::TUpdated& CComment_rule_Base::SetUpdated(void)
{
#ifdef _DEBUG
    if (!IsSetUpdated()) {
        memset(&m_Updated,UnassignedByte(),sizeof(m_Updated));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_Updated;
}
 
inline
bool CComment_rule_Base::IsSetFields(void) const
{
    return m_Fields.NotEmpty();
}
 
inline
bool CComment_rule_Base::CanGetFields(void) const
{
    return true;
}
 
inline
const CComment_rule_Base::TFields& CComment_rule_Base::GetFields(void) const
{
    if ( !m_Fields ) {
        const_cast<CComment_rule_Base*>(this)->ResetFields();
    }
    return (*m_Fields);
}
 
inline
CComment_rule_Base::TFields& CComment_rule_Base::SetFields(void)
{
    if ( !m_Fields ) {
        ResetFields();
    }
    return (*m_Fields);
}
 
inline
bool CComment_rule_Base::IsSetRequire_order(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CComment_rule_Base::CanGetRequire_order(void) const
{
    return true;
}
 
inline
void CComment_rule_Base::ResetRequire_order(void)
{
    m_Require_order = true;
    m_set_State[0] &= ~0xc0;
}
 
inline
void CComment_rule_Base::SetDefaultRequire_order(void)
{
    ResetRequire_order();
}
 
inline
CComment_rule_Base::TRequire_order CComment_rule_Base::GetRequire_order(void) const
{
    return m_Require_order;
}
 
inline
void CComment_rule_Base::SetRequire_order(CComment_rule_Base::TRequire_order value)
{
    m_Require_order = value;
    m_set_State[0] |= 0xc0;
}
 
inline
CComment_rule_Base::TRequire_order& CComment_rule_Base::SetRequire_order(void)
{
#ifdef _DEBUG
    if (!IsSetRequire_order()) {
        memset(&m_Require_order,UnassignedByte(),sizeof(m_Require_order));
    }
#endif
    m_set_State[0] |= 0x40;
    return m_Require_order;
}
 
inline
bool CComment_rule_Base::IsSetAllow_unlisted(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CComment_rule_Base::CanGetAllow_unlisted(void) const
{
    return true;
}
 
inline
void CComment_rule_Base::ResetAllow_unlisted(void)
{
    m_Allow_unlisted = false;
    m_set_State[0] &= ~0x300;
}
 
inline
void CComment_rule_Base::SetDefaultAllow_unlisted(void)
{
    ResetAllow_unlisted();
}
 
inline
CComment_rule_Base::TAllow_unlisted CComment_rule_Base::GetAllow_unlisted(void) const
{
    return m_Allow_unlisted;
}
 
inline
void CComment_rule_Base::SetAllow_unlisted(CComment_rule_Base::TAllow_unlisted value)
{
    m_Allow_unlisted = value;
    m_set_State[0] |= 0x300;
}
 
inline
CComment_rule_Base::TAllow_unlisted& CComment_rule_Base::SetAllow_unlisted(void)
{
#ifdef _DEBUG
    if (!IsSetAllow_unlisted()) {
        memset(&m_Allow_unlisted,UnassignedByte(),sizeof(m_Allow_unlisted));
    }
#endif
    m_set_State[0] |= 0x100;
    return m_Allow_unlisted;
}
 
inline
bool CComment_rule_Base::IsSetDependent_rules(void) const
{
    return m_Dependent_rules.NotEmpty();
}
 
inline
bool CComment_rule_Base::CanGetDependent_rules(void) const
{
    return IsSetDependent_rules();
}
 
inline
const CComment_rule_Base::TDependent_rules& CComment_rule_Base::GetDependent_rules(void) const
{
    if (!CanGetDependent_rules()) {
        ThrowUnassigned(5);
    }
    return (*m_Dependent_rules);
}
 
inline
bool CComment_rule_Base::IsSetForbidden_phrases(void) const
{
    return m_Forbidden_phrases.NotEmpty();
}
 
inline
bool CComment_rule_Base::CanGetForbidden_phrases(void) const
{
    return IsSetForbidden_phrases();
}
 
inline
const CComment_rule_Base::TForbidden_phrases& CComment_rule_Base::GetForbidden_phrases(void) const
{
    if (!CanGetForbidden_phrases()) {
        ThrowUnassigned(6);
    }
    return (*m_Forbidden_phrases);
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJECTS_VALID_COMMENT_RULE_BASE_HPP