Macro_action_choice_.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:
 *   'macro.asn'.
 *
 * 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 <objects/macro/Macro_action_choice.hpp>
#include <objects/macro/AECR_action.hpp>
#include <objects/macro/Add_descriptor_list_action.hpp>
#include <objects/macro/Adjus_featu_for_gaps_actio.hpp>
#include <objects/macro/Apply_feature_action.hpp>
#include <objects/macro/Apply_table_action.hpp>
#include <objects/macro/Author_fix_action.hpp>
#include <objects/macro/Autodef_action.hpp>
#include <objects/macro/Autofix_action.hpp>
#include <objects/macro/Convert_feature_action.hpp>
#include <objects/macro/Create_TSA_ids_action.hpp>
#include <objects/macro/Edit_featur_locatio_action.hpp>
#include <objects/macro/Fix_caps_action.hpp>
#include <objects/macro/Fix_format_action.hpp>
#include <objects/macro/Fix_pub_caps_action.hpp>
#include <objects/macro/Fix_sets_action.hpp>
#include <objects/macro/Make_gene_xref_action.hpp>
#include <objects/macro/Molinfo_block.hpp>
#include <objects/macro/Parse_action.hpp>
#include <objects/macro/Remov_duplic_featur_action.hpp>
#include <objects/macro/Remove_descriptor_action.hpp>
#include <objects/macro/Remove_feature_action.hpp>
#include <objects/macro/Remove_sequences_action.hpp>
#include <objects/macro/Remove_xrefs_action.hpp>
#include <objects/macro/Retranslate_cds_action.hpp>
#include <objects/macro/Sort_fields_action.hpp>
#include <objects/macro/Updat_repla_ec_numbe_actio.hpp>
#include <objects/macro/Update_sequences_action.hpp>
BEGIN_NCBI_SCOPE
 
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// generated classes
 
void CMacro_action_choice_Base::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMacro_action_choice_Base::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Aecr:
    case e_Parse:
    case e_Add_feature:
    case e_Remove_feature:
    case e_Convert_feature:
    case e_Edit_location:
    case e_Remove_descriptor:
    case e_Autodef:
    case e_Fix_pub_caps:
    case e_Sort_fields:
    case e_Apply_molinfo_block:
    case e_Fix_caps:
    case e_Fix_format:
    case e_Remove_duplicate_features:
    case e_Remove_xrefs:
    case e_Make_gene_xrefs:
    case e_Fix_author:
    case e_Update_sequences:
    case e_Create_tsa_ids:
    case e_Perform_autofix:
    case e_Fix_sets:
    case e_Apply_table:
    case e_Remove_sequences:
    case e_Add_file_descriptors:
    case e_Update_replaced_ecnumbers:
    case e_Retranslate_cds:
    case e_Adjust_features_for_gaps:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMacro_action_choice_Base::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Aecr:
        (m_object = new(pool) ncbi::objects::CAECR_action())->AddReference();
        break;
    case e_Parse:
        (m_object = new(pool) ncbi::objects::CParse_action())->AddReference();
        break;
    case e_Add_feature:
        (m_object = new(pool) ncbi::objects::CApply_feature_action())->AddReference();
        break;
    case e_Remove_feature:
        (m_object = new(pool) ncbi::objects::CRemove_feature_action())->AddReference();
        break;
    case e_Convert_feature:
        (m_object = new(pool) ncbi::objects::CConvert_feature_action())->AddReference();
        break;
    case e_Edit_location:
        (m_object = new(pool) ncbi::objects::CEdit_feature_location_action())->AddReference();
        break;
    case e_Remove_descriptor:
        (m_object = new(pool) ncbi::objects::CRemove_descriptor_action())->AddReference();
        break;
    case e_Autodef:
        (m_object = new(pool) ncbi::objects::CAutodef_action())->AddReference();
        break;
    case e_Fix_pub_caps:
        (m_object = new(pool) ncbi::objects::CFix_pub_caps_action())->AddReference();
        break;
    case e_Sort_fields:
        (m_object = new(pool) ncbi::objects::CSort_fields_action())->AddReference();
        break;
    case e_Apply_molinfo_block:
        (m_object = new(pool) ncbi::objects::CMolinfo_block())->AddReference();
        break;
    case e_Fix_caps:
        (m_object = new(pool) ncbi::objects::CFix_caps_action())->AddReference();
        break;
    case e_Fix_format:
        (m_object = new(pool) ncbi::objects::CFix_format_action())->AddReference();
        break;
    case e_Remove_duplicate_features:
        (m_object = new(pool) ncbi::objects::CRemove_duplicate_feature_action())->AddReference();
        break;
    case e_Remove_xrefs:
        (m_object = new(pool) ncbi::objects::CRemove_xrefs_action())->AddReference();
        break;
    case e_Make_gene_xrefs:
        (m_object = new(pool) ncbi::objects::CMake_gene_xref_action())->AddReference();
        break;
    case e_Fix_author:
        (m_object = new(pool) ncbi::objects::CAuthor_fix_action())->AddReference();
        break;
    case e_Update_sequences:
        (m_object = new(pool) ncbi::objects::CUpdate_sequences_action())->AddReference();
        break;
    case e_Create_tsa_ids:
        (m_object = new(pool) ncbi::objects::CCreate_TSA_ids_action())->AddReference();
        break;
    case e_Perform_autofix:
        (m_object = new(pool) ncbi::objects::CAutofix_action())->AddReference();
        break;
    case e_Fix_sets:
        (m_object = new(pool) ncbi::objects::CFix_sets_action())->AddReference();
        break;
    case e_Apply_table:
        (m_object = new(pool) ncbi::objects::CApply_table_action())->AddReference();
        break;
    case e_Remove_sequences:
        (m_object = new(pool) ncbi::objects::CRemove_sequences_action())->AddReference();
        break;
    case e_Add_file_descriptors:
        (m_object = new(pool) ncbi::objects::CAdd_descriptor_list_action())->AddReference();
        break;
    case e_Update_replaced_ecnumbers:
        (m_object = new(pool) ncbi::objects::CUpdate_replaced_ec_numbers_action())->AddReference();
        break;
    case e_Retranslate_cds:
        (m_object = new(pool) ncbi::objects::CRetranslate_cds_action())->AddReference();
        break;
    case e_Adjust_features_for_gaps:
        (m_object = new(pool) ncbi::objects::CAdjust_features_for_gaps_action())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMacro_action_choice_Base::sm_SelectionNames[] = {
    "not set",
    "aecr",
    "parse",
    "add-feature",
    "remove-feature",
    "convert-feature",
    "edit-location",
    "remove-descriptor",
    "autodef",
    "removesets",
    "trim-junk-from-primer-seq",
    "trim-stop-from-complete-cds",
    "fix-usa-and-states",
    "synchronize-cds-partials",
    "adjust-for-consensus-splice",
    "fix-pub-caps",
    "remove-seg-gaps",
    "sort-fields",
    "apply-molinfo-block",
    "fix-caps",
    "fix-format",
    "fix-spell",
    "remove-duplicate-features",
    "remove-lineage-notes",
    "remove-xrefs",
    "make-gene-xrefs",
    "make-bold-xrefs",
    "fix-author",
    "update-sequences",
    "add-trans-splicing",
    "remove-invalid-ecnumbers",
    "create-tsa-ids",
    "perform-autofix",
    "fix-sets",
    "apply-table",
    "remove-sequences",
    "propagate-sequence-technology",
    "add-file-descriptors",
    "propagate-missing-old-name",
    "autoapply-structured-comments",
    "reorder-structured-comments",
    "remove-duplicate-structured-comments",
    "lookup-taxonomy",
    "lookup-pubs",
    "trim-terminal-ns",
    "update-replaced-ecnumbers",
    "instantiate-protein-titles",
    "retranslate-cds",
    "add-selenocysteine-except",
    "join-short-trnas",
    "adjust-features-for-gaps"
};
 
NCBI_NS_STD::string CMacro_action_choice_Base::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMacro_action_choice_Base::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 CMacro_action_choice_Base::TAecr& CMacro_action_choice_Base::GetAecr(void) const
{
    CheckSelected(e_Aecr);
    return *static_cast<const TAecr*>(m_object);
}
 
CMacro_action_choice_Base::TAecr& CMacro_action_choice_Base::SetAecr(void)
{
    Select(e_Aecr, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TAecr*>(m_object);
}
 
void CMacro_action_choice_Base::SetAecr(CMacro_action_choice_Base::TAecr& value)
{
    TAecr* ptr = &value;
    if ( m_choice != e_Aecr || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Aecr;
    }
}
 
const CMacro_action_choice_Base::TParse& CMacro_action_choice_Base::GetParse(void) const
{
    CheckSelected(e_Parse);
    return *static_cast<const TParse*>(m_object);
}
 
CMacro_action_choice_Base::TParse& CMacro_action_choice_Base::SetParse(void)
{
    Select(e_Parse, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TParse*>(m_object);
}
 
void CMacro_action_choice_Base::SetParse(CMacro_action_choice_Base::TParse& value)
{
    TParse* ptr = &value;
    if ( m_choice != e_Parse || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Parse;
    }
}
 
const CMacro_action_choice_Base::TAdd_feature& CMacro_action_choice_Base::GetAdd_feature(void) const
{
    CheckSelected(e_Add_feature);
    return *static_cast<const TAdd_feature*>(m_object);
}
 
CMacro_action_choice_Base::TAdd_feature& CMacro_action_choice_Base::SetAdd_feature(void)
{
    Select(e_Add_feature, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TAdd_feature*>(m_object);
}
 
void CMacro_action_choice_Base::SetAdd_feature(CMacro_action_choice_Base::TAdd_feature& value)
{
    TAdd_feature* ptr = &value;
    if ( m_choice != e_Add_feature || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Add_feature;
    }
}
 
const CMacro_action_choice_Base::TRemove_feature& CMacro_action_choice_Base::GetRemove_feature(void) const
{
    CheckSelected(e_Remove_feature);
    return *static_cast<const TRemove_feature*>(m_object);
}
 
CMacro_action_choice_Base::TRemove_feature& CMacro_action_choice_Base::SetRemove_feature(void)
{
    Select(e_Remove_feature, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRemove_feature*>(m_object);
}
 
void CMacro_action_choice_Base::SetRemove_feature(CMacro_action_choice_Base::TRemove_feature& value)
{
    TRemove_feature* ptr = &value;
    if ( m_choice != e_Remove_feature || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Remove_feature;
    }
}
 
const CMacro_action_choice_Base::TConvert_feature& CMacro_action_choice_Base::GetConvert_feature(void) const
{
    CheckSelected(e_Convert_feature);
    return *static_cast<const TConvert_feature*>(m_object);
}
 
CMacro_action_choice_Base::TConvert_feature& CMacro_action_choice_Base::SetConvert_feature(void)
{
    Select(e_Convert_feature, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TConvert_feature*>(m_object);
}
 
void CMacro_action_choice_Base::SetConvert_feature(CMacro_action_choice_Base::TConvert_feature& value)
{
    TConvert_feature* ptr = &value;
    if ( m_choice != e_Convert_feature || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Convert_feature;
    }
}
 
const CMacro_action_choice_Base::TEdit_location& CMacro_action_choice_Base::GetEdit_location(void) const
{
    CheckSelected(e_Edit_location);
    return *static_cast<const TEdit_location*>(m_object);
}
 
CMacro_action_choice_Base::TEdit_location& CMacro_action_choice_Base::SetEdit_location(void)
{
    Select(e_Edit_location, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TEdit_location*>(m_object);
}
 
void CMacro_action_choice_Base::SetEdit_location(CMacro_action_choice_Base::TEdit_location& value)
{
    TEdit_location* ptr = &value;
    if ( m_choice != e_Edit_location || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Edit_location;
    }
}
 
const CMacro_action_choice_Base::TRemove_descriptor& CMacro_action_choice_Base::GetRemove_descriptor(void) const
{
    CheckSelected(e_Remove_descriptor);
    return *static_cast<const TRemove_descriptor*>(m_object);
}
 
CMacro_action_choice_Base::TRemove_descriptor& CMacro_action_choice_Base::SetRemove_descriptor(void)
{
    Select(e_Remove_descriptor, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRemove_descriptor*>(m_object);
}
 
void CMacro_action_choice_Base::SetRemove_descriptor(CMacro_action_choice_Base::TRemove_descriptor& value)
{
    TRemove_descriptor* ptr = &value;
    if ( m_choice != e_Remove_descriptor || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Remove_descriptor;
    }
}
 
const CMacro_action_choice_Base::TAutodef& CMacro_action_choice_Base::GetAutodef(void) const
{
    CheckSelected(e_Autodef);
    return *static_cast<const TAutodef*>(m_object);
}
 
CMacro_action_choice_Base::TAutodef& CMacro_action_choice_Base::SetAutodef(void)
{
    Select(e_Autodef, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TAutodef*>(m_object);
}
 
void CMacro_action_choice_Base::SetAutodef(CMacro_action_choice_Base::TAutodef& value)
{
    TAutodef* ptr = &value;
    if ( m_choice != e_Autodef || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Autodef;
    }
}
 
const CMacro_action_choice_Base::TFix_pub_caps& CMacro_action_choice_Base::GetFix_pub_caps(void) const
{
    CheckSelected(e_Fix_pub_caps);
    return *static_cast<const TFix_pub_caps*>(m_object);
}
 
CMacro_action_choice_Base::TFix_pub_caps& CMacro_action_choice_Base::SetFix_pub_caps(void)
{
    Select(e_Fix_pub_caps, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TFix_pub_caps*>(m_object);
}
 
void CMacro_action_choice_Base::SetFix_pub_caps(CMacro_action_choice_Base::TFix_pub_caps& value)
{
    TFix_pub_caps* ptr = &value;
    if ( m_choice != e_Fix_pub_caps || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Fix_pub_caps;
    }
}
 
const CMacro_action_choice_Base::TSort_fields& CMacro_action_choice_Base::GetSort_fields(void) const
{
    CheckSelected(e_Sort_fields);
    return *static_cast<const TSort_fields*>(m_object);
}
 
CMacro_action_choice_Base::TSort_fields& CMacro_action_choice_Base::SetSort_fields(void)
{
    Select(e_Sort_fields, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSort_fields*>(m_object);
}
 
void CMacro_action_choice_Base::SetSort_fields(CMacro_action_choice_Base::TSort_fields& value)
{
    TSort_fields* ptr = &value;
    if ( m_choice != e_Sort_fields || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Sort_fields;
    }
}
 
const CMacro_action_choice_Base::TApply_molinfo_block& CMacro_action_choice_Base::GetApply_molinfo_block(void) const
{
    CheckSelected(e_Apply_molinfo_block);
    return *static_cast<const TApply_molinfo_block*>(m_object);
}
 
CMacro_action_choice_Base::TApply_molinfo_block& CMacro_action_choice_Base::SetApply_molinfo_block(void)
{
    Select(e_Apply_molinfo_block, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TApply_molinfo_block*>(m_object);
}
 
void CMacro_action_choice_Base::SetApply_molinfo_block(CMacro_action_choice_Base::TApply_molinfo_block& value)
{
    TApply_molinfo_block* ptr = &value;
    if ( m_choice != e_Apply_molinfo_block || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Apply_molinfo_block;
    }
}
 
const CMacro_action_choice_Base::TFix_caps& CMacro_action_choice_Base::GetFix_caps(void) const
{
    CheckSelected(e_Fix_caps);
    return *static_cast<const TFix_caps*>(m_object);
}
 
CMacro_action_choice_Base::TFix_caps& CMacro_action_choice_Base::SetFix_caps(void)
{
    Select(e_Fix_caps, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TFix_caps*>(m_object);
}
 
void CMacro_action_choice_Base::SetFix_caps(CMacro_action_choice_Base::TFix_caps& value)
{
    TFix_caps* ptr = &value;
    if ( m_choice != e_Fix_caps || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Fix_caps;
    }
}
 
const CMacro_action_choice_Base::TFix_format& CMacro_action_choice_Base::GetFix_format(void) const
{
    CheckSelected(e_Fix_format);
    return *static_cast<const TFix_format*>(m_object);
}
 
CMacro_action_choice_Base::TFix_format& CMacro_action_choice_Base::SetFix_format(void)
{
    Select(e_Fix_format, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TFix_format*>(m_object);
}
 
void CMacro_action_choice_Base::SetFix_format(CMacro_action_choice_Base::TFix_format& value)
{
    TFix_format* ptr = &value;
    if ( m_choice != e_Fix_format || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Fix_format;
    }
}
 
const CMacro_action_choice_Base::TRemove_duplicate_features& CMacro_action_choice_Base::GetRemove_duplicate_features(void) const
{
    CheckSelected(e_Remove_duplicate_features);
    return *static_cast<const TRemove_duplicate_features*>(m_object);
}
 
CMacro_action_choice_Base::TRemove_duplicate_features& CMacro_action_choice_Base::SetRemove_duplicate_features(void)
{
    Select(e_Remove_duplicate_features, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRemove_duplicate_features*>(m_object);
}
 
void CMacro_action_choice_Base::SetRemove_duplicate_features(CMacro_action_choice_Base::TRemove_duplicate_features& value)
{
    TRemove_duplicate_features* ptr = &value;
    if ( m_choice != e_Remove_duplicate_features || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Remove_duplicate_features;
    }
}
 
const CMacro_action_choice_Base::TRemove_xrefs& CMacro_action_choice_Base::GetRemove_xrefs(void) const
{
    CheckSelected(e_Remove_xrefs);
    return *static_cast<const TRemove_xrefs*>(m_object);
}
 
CMacro_action_choice_Base::TRemove_xrefs& CMacro_action_choice_Base::SetRemove_xrefs(void)
{
    Select(e_Remove_xrefs, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRemove_xrefs*>(m_object);
}
 
void CMacro_action_choice_Base::SetRemove_xrefs(CMacro_action_choice_Base::TRemove_xrefs& value)
{
    TRemove_xrefs* ptr = &value;
    if ( m_choice != e_Remove_xrefs || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Remove_xrefs;
    }
}
 
const CMacro_action_choice_Base::TMake_gene_xrefs& CMacro_action_choice_Base::GetMake_gene_xrefs(void) const
{
    CheckSelected(e_Make_gene_xrefs);
    return *static_cast<const TMake_gene_xrefs*>(m_object);
}
 
CMacro_action_choice_Base::TMake_gene_xrefs& CMacro_action_choice_Base::SetMake_gene_xrefs(void)
{
    Select(e_Make_gene_xrefs, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMake_gene_xrefs*>(m_object);
}
 
void CMacro_action_choice_Base::SetMake_gene_xrefs(CMacro_action_choice_Base::TMake_gene_xrefs& value)
{
    TMake_gene_xrefs* ptr = &value;
    if ( m_choice != e_Make_gene_xrefs || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Make_gene_xrefs;
    }
}
 
const CMacro_action_choice_Base::TFix_author& CMacro_action_choice_Base::GetFix_author(void) const
{
    CheckSelected(e_Fix_author);
    return *static_cast<const TFix_author*>(m_object);
}
 
CMacro_action_choice_Base::TFix_author& CMacro_action_choice_Base::SetFix_author(void)
{
    Select(e_Fix_author, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TFix_author*>(m_object);
}
 
void CMacro_action_choice_Base::SetFix_author(CMacro_action_choice_Base::TFix_author& value)
{
    TFix_author* ptr = &value;
    if ( m_choice != e_Fix_author || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Fix_author;
    }
}
 
const CMacro_action_choice_Base::TUpdate_sequences& CMacro_action_choice_Base::GetUpdate_sequences(void) const
{
    CheckSelected(e_Update_sequences);
    return *static_cast<const TUpdate_sequences*>(m_object);
}
 
CMacro_action_choice_Base::TUpdate_sequences& CMacro_action_choice_Base::SetUpdate_sequences(void)
{
    Select(e_Update_sequences, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TUpdate_sequences*>(m_object);
}
 
void CMacro_action_choice_Base::SetUpdate_sequences(CMacro_action_choice_Base::TUpdate_sequences& value)
{
    TUpdate_sequences* ptr = &value;
    if ( m_choice != e_Update_sequences || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Update_sequences;
    }
}
 
const CMacro_action_choice_Base::TCreate_tsa_ids& CMacro_action_choice_Base::GetCreate_tsa_ids(void) const
{
    CheckSelected(e_Create_tsa_ids);
    return *static_cast<const TCreate_tsa_ids*>(m_object);
}
 
CMacro_action_choice_Base::TCreate_tsa_ids& CMacro_action_choice_Base::SetCreate_tsa_ids(void)
{
    Select(e_Create_tsa_ids, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCreate_tsa_ids*>(m_object);
}
 
void CMacro_action_choice_Base::SetCreate_tsa_ids(CMacro_action_choice_Base::TCreate_tsa_ids& value)
{
    TCreate_tsa_ids* ptr = &value;
    if ( m_choice != e_Create_tsa_ids || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Create_tsa_ids;
    }
}
 
const CMacro_action_choice_Base::TPerform_autofix& CMacro_action_choice_Base::GetPerform_autofix(void) const
{
    CheckSelected(e_Perform_autofix);
    return *static_cast<const TPerform_autofix*>(m_object);
}
 
CMacro_action_choice_Base::TPerform_autofix& CMacro_action_choice_Base::SetPerform_autofix(void)
{
    Select(e_Perform_autofix, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TPerform_autofix*>(m_object);
}
 
void CMacro_action_choice_Base::SetPerform_autofix(CMacro_action_choice_Base::TPerform_autofix& value)
{
    TPerform_autofix* ptr = &value;
    if ( m_choice != e_Perform_autofix || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Perform_autofix;
    }
}
 
const CMacro_action_choice_Base::TFix_sets& CMacro_action_choice_Base::GetFix_sets(void) const
{
    CheckSelected(e_Fix_sets);
    return *static_cast<const TFix_sets*>(m_object);
}
 
CMacro_action_choice_Base::TFix_sets& CMacro_action_choice_Base::SetFix_sets(void)
{
    Select(e_Fix_sets, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TFix_sets*>(m_object);
}
 
void CMacro_action_choice_Base::SetFix_sets(CMacro_action_choice_Base::TFix_sets& value)
{
    TFix_sets* ptr = &value;
    if ( m_choice != e_Fix_sets || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Fix_sets;
    }
}
 
const CMacro_action_choice_Base::TApply_table& CMacro_action_choice_Base::GetApply_table(void) const
{
    CheckSelected(e_Apply_table);
    return *static_cast<const TApply_table*>(m_object);
}
 
CMacro_action_choice_Base::TApply_table& CMacro_action_choice_Base::SetApply_table(void)
{
    Select(e_Apply_table, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TApply_table*>(m_object);
}
 
void CMacro_action_choice_Base::SetApply_table(CMacro_action_choice_Base::TApply_table& value)
{
    TApply_table* ptr = &value;
    if ( m_choice != e_Apply_table || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Apply_table;
    }
}
 
const CMacro_action_choice_Base::TRemove_sequences& CMacro_action_choice_Base::GetRemove_sequences(void) const
{
    CheckSelected(e_Remove_sequences);
    return *static_cast<const TRemove_sequences*>(m_object);
}
 
CMacro_action_choice_Base::TRemove_sequences& CMacro_action_choice_Base::SetRemove_sequences(void)
{
    Select(e_Remove_sequences, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRemove_sequences*>(m_object);
}
 
void CMacro_action_choice_Base::SetRemove_sequences(CMacro_action_choice_Base::TRemove_sequences& value)
{
    TRemove_sequences* ptr = &value;
    if ( m_choice != e_Remove_sequences || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Remove_sequences;
    }
}
 
const CMacro_action_choice_Base::TAdd_file_descriptors& CMacro_action_choice_Base::GetAdd_file_descriptors(void) const
{
    CheckSelected(e_Add_file_descriptors);
    return *static_cast<const TAdd_file_descriptors*>(m_object);
}
 
CMacro_action_choice_Base::TAdd_file_descriptors& CMacro_action_choice_Base::SetAdd_file_descriptors(void)
{
    Select(e_Add_file_descriptors, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TAdd_file_descriptors*>(m_object);
}
 
void CMacro_action_choice_Base::SetAdd_file_descriptors(CMacro_action_choice_Base::TAdd_file_descriptors& value)
{
    TAdd_file_descriptors* ptr = &value;
    if ( m_choice != e_Add_file_descriptors || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Add_file_descriptors;
    }
}
 
const CMacro_action_choice_Base::TUpdate_replaced_ecnumbers& CMacro_action_choice_Base::GetUpdate_replaced_ecnumbers(void) const
{
    CheckSelected(e_Update_replaced_ecnumbers);
    return *static_cast<const TUpdate_replaced_ecnumbers*>(m_object);
}
 
CMacro_action_choice_Base::TUpdate_replaced_ecnumbers& CMacro_action_choice_Base::SetUpdate_replaced_ecnumbers(void)
{
    Select(e_Update_replaced_ecnumbers, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TUpdate_replaced_ecnumbers*>(m_object);
}
 
void CMacro_action_choice_Base::SetUpdate_replaced_ecnumbers(CMacro_action_choice_Base::TUpdate_replaced_ecnumbers& value)
{
    TUpdate_replaced_ecnumbers* ptr = &value;
    if ( m_choice != e_Update_replaced_ecnumbers || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Update_replaced_ecnumbers;
    }
}
 
const CMacro_action_choice_Base::TRetranslate_cds& CMacro_action_choice_Base::GetRetranslate_cds(void) const
{
    CheckSelected(e_Retranslate_cds);
    return *static_cast<const TRetranslate_cds*>(m_object);
}
 
CMacro_action_choice_Base::TRetranslate_cds& CMacro_action_choice_Base::SetRetranslate_cds(void)
{
    Select(e_Retranslate_cds, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRetranslate_cds*>(m_object);
}
 
void CMacro_action_choice_Base::SetRetranslate_cds(CMacro_action_choice_Base::TRetranslate_cds& value)
{
    TRetranslate_cds* ptr = &value;
    if ( m_choice != e_Retranslate_cds || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Retranslate_cds;
    }
}
 
const CMacro_action_choice_Base::TAdjust_features_for_gaps& CMacro_action_choice_Base::GetAdjust_features_for_gaps(void) const
{
    CheckSelected(e_Adjust_features_for_gaps);
    return *static_cast<const TAdjust_features_for_gaps*>(m_object);
}
 
CMacro_action_choice_Base::TAdjust_features_for_gaps& CMacro_action_choice_Base::SetAdjust_features_for_gaps(void)
{
    Select(e_Adjust_features_for_gaps, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TAdjust_features_for_gaps*>(m_object);
}
 
void CMacro_action_choice_Base::SetAdjust_features_for_gaps(CMacro_action_choice_Base::TAdjust_features_for_gaps& value)
{
    TAdjust_features_for_gaps* ptr = &value;
    if ( m_choice != e_Adjust_features_for_gaps || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Adjust_features_for_gaps;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_BASE_CHOICE_INFO("Macro-action-choice", CMacro_action_choice)
{
    SET_CHOICE_MODULE("NCBI-Macro");
    ADD_NAMED_REF_CHOICE_VARIANT("aecr", m_object, CAECR_action);
    ADD_NAMED_REF_CHOICE_VARIANT("parse", m_object, CParse_action);
    ADD_NAMED_REF_CHOICE_VARIANT("add-feature", m_object, CApply_feature_action);
    ADD_NAMED_REF_CHOICE_VARIANT("remove-feature", m_object, CRemove_feature_action);
    ADD_NAMED_REF_CHOICE_VARIANT("convert-feature", m_object, CConvert_feature_action);
    ADD_NAMED_REF_CHOICE_VARIANT("edit-location", m_object, CEdit_feature_location_action);
    ADD_NAMED_REF_CHOICE_VARIANT("remove-descriptor", m_object, CRemove_descriptor_action);
    ADD_NAMED_REF_CHOICE_VARIANT("autodef", m_object, CAutodef_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("removesets", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("trim-junk-from-primer-seq", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("trim-stop-from-complete-cds", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("fix-usa-and-states", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("synchronize-cds-partials", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("adjust-for-consensus-splice", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("fix-pub-caps", m_object, CFix_pub_caps_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("remove-seg-gaps", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("sort-fields", m_object, CSort_fields_action);
    ADD_NAMED_REF_CHOICE_VARIANT("apply-molinfo-block", m_object, CMolinfo_block);
    ADD_NAMED_REF_CHOICE_VARIANT("fix-caps", m_object, CFix_caps_action);
    ADD_NAMED_REF_CHOICE_VARIANT("fix-format", m_object, CFix_format_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("fix-spell", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("remove-duplicate-features", m_object, CRemove_duplicate_feature_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("remove-lineage-notes", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("remove-xrefs", m_object, CRemove_xrefs_action);
    ADD_NAMED_REF_CHOICE_VARIANT("make-gene-xrefs", m_object, CMake_gene_xref_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("make-bold-xrefs", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("fix-author", m_object, CAuthor_fix_action);
    ADD_NAMED_REF_CHOICE_VARIANT("update-sequences", m_object, CUpdate_sequences_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("add-trans-splicing", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("remove-invalid-ecnumbers", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("create-tsa-ids", m_object, CCreate_TSA_ids_action);
    ADD_NAMED_REF_CHOICE_VARIANT("perform-autofix", m_object, CAutofix_action);
    ADD_NAMED_REF_CHOICE_VARIANT("fix-sets", m_object, CFix_sets_action);
    ADD_NAMED_REF_CHOICE_VARIANT("apply-table", m_object, CApply_table_action);
    ADD_NAMED_REF_CHOICE_VARIANT("remove-sequences", m_object, CRemove_sequences_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("propagate-sequence-technology", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("add-file-descriptors", m_object, CAdd_descriptor_list_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("propagate-missing-old-name", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("autoapply-structured-comments", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("reorder-structured-comments", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("remove-duplicate-structured-comments", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("lookup-taxonomy", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("lookup-pubs", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("trim-terminal-ns", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("update-replaced-ecnumbers", m_object, CUpdate_replaced_ec_numbers_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("instantiate-protein-titles", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("retranslate-cds", m_object, CRetranslate_cds_action);
    ADD_NAMED_NULL_CHOICE_VARIANT("add-selenocysteine-except", null, ());
    ADD_NAMED_NULL_CHOICE_VARIANT("join-short-trnas", null, ());
    ADD_NAMED_REF_CHOICE_VARIANT("adjust-features-for-gaps", m_object, CAdjust_features_for_gaps_action);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eASN);
}
END_CHOICE_INFO
 
// constructor
CMacro_action_choice_Base::CMacro_action_choice_Base(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMacro_action_choice_Base::~CMacro_action_choice_Base(void)
{
    Reset();
}
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE