TMgr_Request_.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:
 *   'trackmgr.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/trackmgr/TMgr_Request.hpp>
#include <objects/trackmgr/TMgr_BlastRIDRequest.hpp>
#include <objects/trackmgr/TMgr_CreateRemoteTrackRequ.hpp>
#include <objects/trackmgr/TMgr_CreateTracksetRequest.hpp>
#include <objects/trackmgr/TMgr_CreateUserTrackReques.hpp>
#include <objects/trackmgr/TMgr_DisplayTrackRequest.hpp>
#include <objects/trackmgr/TMgr_ItemResolverRequest.hpp>
#include <objects/trackmgr/TMgr_RemoveUserTrackReques.hpp>
#include <objects/trackmgr/TMgr_RenameMyNCBICollectix.hpp>
#include <objects/trackmgr/TMgr_RetrieveTracksetReque.hpp>
#include <objects/trackmgr/TMgr_SupportedAssembliesRx.hpp>
#include <objects/trackmgr/TMgr_SwitchTrackContextReq.hpp>
#include <objects/trackmgr/TMgr_TrackAttrValueRequest.hpp>
BEGIN_NCBI_SCOPE
 
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// generated classes
 
void CTMgr_Request_Base::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CTMgr_Request_Base::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Display_tracks:
    case e_Switch_display_tracks:
    case e_Track_attr_values:
    case e_Blast_tracks:
    case e_Create_user_tracks:
    case e_Create_remote_tracks:
    case e_Resolve_track_items:
    case e_Remove_user_tracks:
    case e_Retrieve_tracksets:
    case e_Create_trackset:
    case e_Rename_trackset:
    case e_Supported_assemblies:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CTMgr_Request_Base::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Display_tracks:
        (m_object = new(pool) ncbi::objects::CTMgr_DisplayTrackRequest())->AddReference();
        break;
    case e_Switch_display_tracks:
        (m_object = new(pool) ncbi::objects::CTMgr_SwitchTrackContextRequest())->AddReference();
        break;
    case e_Track_attr_values:
        (m_object = new(pool) ncbi::objects::CTMgr_TrackAttrValueRequest())->AddReference();
        break;
    case e_Blast_tracks:
        (m_object = new(pool) ncbi::objects::CTMgr_BlastRIDRequest())->AddReference();
        break;
    case e_Create_user_tracks:
        (m_object = new(pool) ncbi::objects::CTMgr_CreateUserTrackRequest())->AddReference();
        break;
    case e_Create_remote_tracks:
        (m_object = new(pool) ncbi::objects::CTMgr_CreateRemoteTrackRequest())->AddReference();
        break;
    case e_Resolve_track_items:
        (m_object = new(pool) ncbi::objects::CTMgr_ItemResolverRequest())->AddReference();
        break;
    case e_Remove_user_tracks:
        (m_object = new(pool) ncbi::objects::CTMgr_RemoveUserTrackRequest())->AddReference();
        break;
    case e_Retrieve_tracksets:
        (m_object = new(pool) ncbi::objects::CTMgr_RetrieveTracksetRequest())->AddReference();
        break;
    case e_Create_trackset:
        (m_object = new(pool) ncbi::objects::CTMgr_CreateTracksetRequest())->AddReference();
        break;
    case e_Rename_trackset:
        (m_object = new(pool) ncbi::objects::CTMgr_RenameMyNCBICollectionRequest())->AddReference();
        break;
    case e_Supported_assemblies:
        (m_object = new(pool) ncbi::objects::CTMgr_SupportedAssembliesRequest())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CTMgr_Request_Base::sm_SelectionNames[] = {
    "not set",
    "display-tracks",
    "switch-display-tracks",
    "track-attr-values",
    "blast-tracks",
    "create-user-tracks",
    "create-remote-tracks",
    "resolve-track-items",
    "remove-user-tracks",
    "retrieve-tracksets",
    "create-trackset",
    "rename-trackset",
    "supported-assemblies"
};
 
NCBI_NS_STD::string CTMgr_Request_Base::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CTMgr_Request_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 CTMgr_Request_Base::TDisplay_tracks& CTMgr_Request_Base::GetDisplay_tracks(void) const
{
    CheckSelected(e_Display_tracks);
    return *static_cast<const TDisplay_tracks*>(m_object);
}
 
CTMgr_Request_Base::TDisplay_tracks& CTMgr_Request_Base::SetDisplay_tracks(void)
{
    Select(e_Display_tracks, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TDisplay_tracks*>(m_object);
}
 
void CTMgr_Request_Base::SetDisplay_tracks(CTMgr_Request_Base::TDisplay_tracks& value)
{
    TDisplay_tracks* ptr = &value;
    if ( m_choice != e_Display_tracks || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Display_tracks;
    }
}
 
const CTMgr_Request_Base::TSwitch_display_tracks& CTMgr_Request_Base::GetSwitch_display_tracks(void) const
{
    CheckSelected(e_Switch_display_tracks);
    return *static_cast<const TSwitch_display_tracks*>(m_object);
}
 
CTMgr_Request_Base::TSwitch_display_tracks& CTMgr_Request_Base::SetSwitch_display_tracks(void)
{
    Select(e_Switch_display_tracks, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSwitch_display_tracks*>(m_object);
}
 
void CTMgr_Request_Base::SetSwitch_display_tracks(CTMgr_Request_Base::TSwitch_display_tracks& value)
{
    TSwitch_display_tracks* ptr = &value;
    if ( m_choice != e_Switch_display_tracks || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Switch_display_tracks;
    }
}
 
const CTMgr_Request_Base::TTrack_attr_values& CTMgr_Request_Base::GetTrack_attr_values(void) const
{
    CheckSelected(e_Track_attr_values);
    return *static_cast<const TTrack_attr_values*>(m_object);
}
 
CTMgr_Request_Base::TTrack_attr_values& CTMgr_Request_Base::SetTrack_attr_values(void)
{
    Select(e_Track_attr_values, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TTrack_attr_values*>(m_object);
}
 
void CTMgr_Request_Base::SetTrack_attr_values(CTMgr_Request_Base::TTrack_attr_values& value)
{
    TTrack_attr_values* ptr = &value;
    if ( m_choice != e_Track_attr_values || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Track_attr_values;
    }
}
 
const CTMgr_Request_Base::TBlast_tracks& CTMgr_Request_Base::GetBlast_tracks(void) const
{
    CheckSelected(e_Blast_tracks);
    return *static_cast<const TBlast_tracks*>(m_object);
}
 
CTMgr_Request_Base::TBlast_tracks& CTMgr_Request_Base::SetBlast_tracks(void)
{
    Select(e_Blast_tracks, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TBlast_tracks*>(m_object);
}
 
void CTMgr_Request_Base::SetBlast_tracks(CTMgr_Request_Base::TBlast_tracks& value)
{
    TBlast_tracks* ptr = &value;
    if ( m_choice != e_Blast_tracks || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Blast_tracks;
    }
}
 
const CTMgr_Request_Base::TCreate_user_tracks& CTMgr_Request_Base::GetCreate_user_tracks(void) const
{
    CheckSelected(e_Create_user_tracks);
    return *static_cast<const TCreate_user_tracks*>(m_object);
}
 
CTMgr_Request_Base::TCreate_user_tracks& CTMgr_Request_Base::SetCreate_user_tracks(void)
{
    Select(e_Create_user_tracks, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCreate_user_tracks*>(m_object);
}
 
void CTMgr_Request_Base::SetCreate_user_tracks(CTMgr_Request_Base::TCreate_user_tracks& value)
{
    TCreate_user_tracks* ptr = &value;
    if ( m_choice != e_Create_user_tracks || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Create_user_tracks;
    }
}
 
const CTMgr_Request_Base::TCreate_remote_tracks& CTMgr_Request_Base::GetCreate_remote_tracks(void) const
{
    CheckSelected(e_Create_remote_tracks);
    return *static_cast<const TCreate_remote_tracks*>(m_object);
}
 
CTMgr_Request_Base::TCreate_remote_tracks& CTMgr_Request_Base::SetCreate_remote_tracks(void)
{
    Select(e_Create_remote_tracks, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCreate_remote_tracks*>(m_object);
}
 
void CTMgr_Request_Base::SetCreate_remote_tracks(CTMgr_Request_Base::TCreate_remote_tracks& value)
{
    TCreate_remote_tracks* ptr = &value;
    if ( m_choice != e_Create_remote_tracks || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Create_remote_tracks;
    }
}
 
const CTMgr_Request_Base::TResolve_track_items& CTMgr_Request_Base::GetResolve_track_items(void) const
{
    CheckSelected(e_Resolve_track_items);
    return *static_cast<const TResolve_track_items*>(m_object);
}
 
CTMgr_Request_Base::TResolve_track_items& CTMgr_Request_Base::SetResolve_track_items(void)
{
    Select(e_Resolve_track_items, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TResolve_track_items*>(m_object);
}
 
void CTMgr_Request_Base::SetResolve_track_items(CTMgr_Request_Base::TResolve_track_items& value)
{
    TResolve_track_items* ptr = &value;
    if ( m_choice != e_Resolve_track_items || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Resolve_track_items;
    }
}
 
const CTMgr_Request_Base::TRemove_user_tracks& CTMgr_Request_Base::GetRemove_user_tracks(void) const
{
    CheckSelected(e_Remove_user_tracks);
    return *static_cast<const TRemove_user_tracks*>(m_object);
}
 
CTMgr_Request_Base::TRemove_user_tracks& CTMgr_Request_Base::SetRemove_user_tracks(void)
{
    Select(e_Remove_user_tracks, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRemove_user_tracks*>(m_object);
}
 
void CTMgr_Request_Base::SetRemove_user_tracks(CTMgr_Request_Base::TRemove_user_tracks& value)
{
    TRemove_user_tracks* ptr = &value;
    if ( m_choice != e_Remove_user_tracks || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Remove_user_tracks;
    }
}
 
const CTMgr_Request_Base::TRetrieve_tracksets& CTMgr_Request_Base::GetRetrieve_tracksets(void) const
{
    CheckSelected(e_Retrieve_tracksets);
    return *static_cast<const TRetrieve_tracksets*>(m_object);
}
 
CTMgr_Request_Base::TRetrieve_tracksets& CTMgr_Request_Base::SetRetrieve_tracksets(void)
{
    Select(e_Retrieve_tracksets, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRetrieve_tracksets*>(m_object);
}
 
void CTMgr_Request_Base::SetRetrieve_tracksets(CTMgr_Request_Base::TRetrieve_tracksets& value)
{
    TRetrieve_tracksets* ptr = &value;
    if ( m_choice != e_Retrieve_tracksets || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Retrieve_tracksets;
    }
}
 
const CTMgr_Request_Base::TCreate_trackset& CTMgr_Request_Base::GetCreate_trackset(void) const
{
    CheckSelected(e_Create_trackset);
    return *static_cast<const TCreate_trackset*>(m_object);
}
 
CTMgr_Request_Base::TCreate_trackset& CTMgr_Request_Base::SetCreate_trackset(void)
{
    Select(e_Create_trackset, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCreate_trackset*>(m_object);
}
 
void CTMgr_Request_Base::SetCreate_trackset(CTMgr_Request_Base::TCreate_trackset& value)
{
    TCreate_trackset* ptr = &value;
    if ( m_choice != e_Create_trackset || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Create_trackset;
    }
}
 
const CTMgr_Request_Base::TRename_trackset& CTMgr_Request_Base::GetRename_trackset(void) const
{
    CheckSelected(e_Rename_trackset);
    return *static_cast<const TRename_trackset*>(m_object);
}
 
CTMgr_Request_Base::TRename_trackset& CTMgr_Request_Base::SetRename_trackset(void)
{
    Select(e_Rename_trackset, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRename_trackset*>(m_object);
}
 
void CTMgr_Request_Base::SetRename_trackset(CTMgr_Request_Base::TRename_trackset& value)
{
    TRename_trackset* ptr = &value;
    if ( m_choice != e_Rename_trackset || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Rename_trackset;
    }
}
 
const CTMgr_Request_Base::TSupported_assemblies& CTMgr_Request_Base::GetSupported_assemblies(void) const
{
    CheckSelected(e_Supported_assemblies);
    return *static_cast<const TSupported_assemblies*>(m_object);
}
 
CTMgr_Request_Base::TSupported_assemblies& CTMgr_Request_Base::SetSupported_assemblies(void)
{
    Select(e_Supported_assemblies, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSupported_assemblies*>(m_object);
}
 
void CTMgr_Request_Base::SetSupported_assemblies(CTMgr_Request_Base::TSupported_assemblies& value)
{
    TSupported_assemblies* ptr = &value;
    if ( m_choice != e_Supported_assemblies || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Supported_assemblies;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_BASE_CHOICE_INFO("TMgr-Request", CTMgr_Request)
{
    SET_CHOICE_MODULE("NCBI-TrackManager");
    ADD_NAMED_REF_CHOICE_VARIANT("display-tracks", m_object, CTMgr_DisplayTrackRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("switch-display-tracks", m_object, CTMgr_SwitchTrackContextRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("track-attr-values", m_object, CTMgr_TrackAttrValueRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("blast-tracks", m_object, CTMgr_BlastRIDRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("create-user-tracks", m_object, CTMgr_CreateUserTrackRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("create-remote-tracks", m_object, CTMgr_CreateRemoteTrackRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("resolve-track-items", m_object, CTMgr_ItemResolverRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("remove-user-tracks", m_object, CTMgr_RemoveUserTrackRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("retrieve-tracksets", m_object, CTMgr_RetrieveTracksetRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("create-trackset", m_object, CTMgr_CreateTracksetRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("rename-trackset", m_object, CTMgr_RenameMyNCBICollectionRequest);
    ADD_NAMED_REF_CHOICE_VARIANT("supported-assemblies", m_object, CTMgr_SupportedAssembliesRequest);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eASN);
}
END_CHOICE_INFO
 
// constructor
CTMgr_Request_Base::CTMgr_Request_Base(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CTMgr_Request_Base::~CTMgr_Request_Base(void)
{
    Reset();
}
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE