Pssm_.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 Pssm_.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/scoremat/scoremat.asn">scoremat.asn</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/scoremat/scoremat.def">scoremat.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJECTS_SCOREMAT_PSSM_BASE_HPP
#define OBJECTS_SCOREMAT_PSSM_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
 
// generated includes
#include <list>
#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 CObject_id;
class CPssmFinalData;
class CPssmIntermediateData;
class CSeq_entry;
 
 
// generated classes
 
 
/** @addtogroup dataspec_NCBI_ScoreMat
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
/// Position-specific scoring matrix
///
/// Column indices on the PSSM refer to the positions corresponding to the
/// query/master sequence, i.e. the number of columns (N) is the same
/// as the length of the query/master sequence. 
/// Row indices refer to individual amino acid types, i.e. the number of 
/// rows (M) is the same as the number of different residues in the 
/// alphabet we use. Consequently, row labels are amino acid identifiers.
///
/// PSSMs are stored as linear arrays of integers. By default, we store
/// them column-by-column, M values for the first column followed by M
/// values for the second column, and so on. In order to provide
/// flexibility for external applications, the boolean field "byrow" is 
/// provided to specify the storage order.
///
/// CPssm_Base --
///
 
class NCBI_SCOREMAT_EXPORT CPssm_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CPssm_Base(void);
    // destructor
    virtual ~CPssm_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    // types
    typedef bool TIsProtein;
    typedef CObject_id TIdentifier;
    typedef int TNumRows;
    typedef int TNumColumns;
    typedef list< string > TRowLabels;
    typedef bool TByRow;
    typedef CSeq_entry TQuery;
    typedef CPssmIntermediateData TIntermediateData;
    typedef CPssmFinalData TFinalData;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_isProtein,
        e_identifier,
        e_numRows,
        e_numColumns,
        e_rowLabels,
        e_byRow,
        e_query,
        e_intermediateData,
        e_finalData
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 10> TmemberIndex;
 
    // getters
    // setters
 
    /// Is the this a protein or nucleotide scoring matrix?
    /// Check if a value has been assigned to IsProtein data member.
    ///
    /// Data member IsProtein is optional with default true;
    /// its type is defined as 'typedef bool TIsProtein'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetIsProtein(void) const;
 
    /// Check if it is safe to call GetIsProtein method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetIsProtein(void) const;
 
    /// Reset IsProtein data member.
    void ResetIsProtein(void);
 
    /// Assign default value to IsProtein data member.
    void SetDefaultIsProtein(void);
 
    /// Get the IsProtein member data.
    ///
    /// @return
    ///   Copy of the member data.
    TIsProtein GetIsProtein(void) const;
 
    /// Assign a value to IsProtein data member.
    ///
    /// @param value
    ///   Value to assign
    void SetIsProtein(TIsProtein value);
 
    /// Assign a value to IsProtein data member.
    ///
    /// @return
    ///   Reference to the data value.
    TIsProtein& SetIsProtein(void);
 
    /// PSSM identifier
    /// Check if a value has been assigned to Identifier data member.
    ///
    /// Data member Identifier is optional;
    /// its type is defined as 'typedef CObject_id TIdentifier'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetIdentifier(void) const;
 
    /// Check if it is safe to call GetIdentifier method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetIdentifier(void) const;
 
    /// Reset Identifier data member.
    void ResetIdentifier(void);
 
    /// Get the Identifier member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TIdentifier& GetIdentifier(void) const;
 
    /// Assign a value to Identifier data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetIdentifier(TIdentifier& value);
 
    /// Assign a value to Identifier data member.
    ///
    /// @return
    ///   Reference to the data value.
    TIdentifier& SetIdentifier(void);
 
    /// The dimensions of the matrix are returned so the client can
    /// verify that all data was received.
    /// number of rows
    /// Check if a value has been assigned to NumRows data member.
    ///
    /// Data member NumRows is mandatory;
    /// its type is defined as 'typedef int TNumRows'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetNumRows(void) const;
 
    /// Check if it is safe to call GetNumRows method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetNumRows(void) const;
 
    /// Reset NumRows data member.
    void ResetNumRows(void);
 
    /// Get the NumRows member data.
    ///
    /// @return
    ///   Copy of the member data.
    TNumRows GetNumRows(void) const;
 
    /// Assign a value to NumRows data member.
    ///
    /// @param value
    ///   Value to assign
    void SetNumRows(TNumRows value);
 
    /// Assign a value to NumRows data member.
    ///
    /// @return
    ///   Reference to the data value.
    TNumRows& SetNumRows(void);
 
    /// number of columns
    /// Check if a value has been assigned to NumColumns data member.
    ///
    /// Data member NumColumns is mandatory;
    /// its type is defined as 'typedef int TNumColumns'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetNumColumns(void) const;
 
    /// Check if it is safe to call GetNumColumns method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetNumColumns(void) const;
 
    /// Reset NumColumns data member.
    void ResetNumColumns(void);
 
    /// Get the NumColumns member data.
    ///
    /// @return
    ///   Copy of the member data.
    TNumColumns GetNumColumns(void) const;
 
    /// Assign a value to NumColumns data member.
    ///
    /// @param value
    ///   Value to assign
    void SetNumColumns(TNumColumns value);
 
    /// Assign a value to NumColumns data member.
    ///
    /// @return
    ///   Reference to the data value.
    TNumColumns& SetNumColumns(void);
 
    /// row-labels is given to note the order of residue types so that it can
    /// be cross-checked between applications.
    /// If this field is not given, the matrix values are presented in 
    /// order of the alphabet ncbistdaa is used for protein, ncbi4na for nucl.
    /// for proteins the values returned correspond to 
    /// (-,-), (-,A), (-,B), (-,C) ... (A,-), (A,A), (A,B), (A,C) ...
    /// Check if a value has been assigned to RowLabels data member.
    ///
    /// Data member RowLabels is optional;
    /// its type is defined as 'typedef list< string > TRowLabels'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetRowLabels(void) const;
 
    /// Check if it is safe to call GetRowLabels method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetRowLabels(void) const;
 
    /// Reset RowLabels data member.
    void ResetRowLabels(void);
 
    /// Get the RowLabels member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TRowLabels& GetRowLabels(void) const;
 
    /// Assign a value to RowLabels data member.
    ///
    /// @return
    ///   Reference to the data value.
    TRowLabels& SetRowLabels(void);
 
    /// are matrices stored row by row?
    /// Check if a value has been assigned to ByRow data member.
    ///
    /// Data member ByRow is optional with default false;
    /// its type is defined as 'typedef bool TByRow'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetByRow(void) const;
 
    /// Check if it is safe to call GetByRow method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetByRow(void) const;
 
    /// Reset ByRow data member.
    void ResetByRow(void);
 
    /// Assign default value to ByRow data member.
    void SetDefaultByRow(void);
 
    /// Get the ByRow member data.
    ///
    /// @return
    ///   Copy of the member data.
    TByRow GetByRow(void) const;
 
    /// Assign a value to ByRow data member.
    ///
    /// @param value
    ///   Value to assign
    void SetByRow(TByRow value);
 
    /// Assign a value to ByRow data member.
    ///
    /// @return
    ///   Reference to the data value.
    TByRow& SetByRow(void);
 
    /// PSSM representative sequence (master) 
    /// Check if a value has been assigned to Query data member.
    ///
    /// Data member Query is optional;
    /// its type is defined as 'typedef CSeq_entry TQuery'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetQuery(void) const;
 
    /// Check if it is safe to call GetQuery method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetQuery(void) const;
 
    /// Reset Query data member.
    void ResetQuery(void);
 
    /// Get the Query member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TQuery& GetQuery(void) const;
 
    /// Assign a value to Query data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetQuery(TQuery& value);
 
    /// Assign a value to Query data member.
    ///
    /// @return
    ///   Reference to the data value.
    TQuery& SetQuery(void);
 
    /// both intermediateData and finalData can be provided, but at least one of
    /// them must be provided.
    /// N.B.: by default PSI-BLAST will return the PSSM in its PssmIntermediateData 
    /// representation. 
    /// Intermediate or final data for the PSSM
    /// Check if a value has been assigned to IntermediateData data member.
    ///
    /// Data member IntermediateData is optional;
    /// its type is defined as 'typedef CPssmIntermediateData TIntermediateData'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetIntermediateData(void) const;
 
    /// Check if it is safe to call GetIntermediateData method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetIntermediateData(void) const;
 
    /// Reset IntermediateData data member.
    void ResetIntermediateData(void);
 
    /// Get the IntermediateData member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TIntermediateData& GetIntermediateData(void) const;
 
    /// Assign a value to IntermediateData data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetIntermediateData(TIntermediateData& value);
 
    /// Assign a value to IntermediateData data member.
    ///
    /// @return
    ///   Reference to the data value.
    TIntermediateData& SetIntermediateData(void);
 
    /// Final representation for the PSSM
    /// Check if a value has been assigned to FinalData data member.
    ///
    /// Data member FinalData is optional;
    /// its type is defined as 'typedef CPssmFinalData TFinalData'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetFinalData(void) const;
 
    /// Check if it is safe to call GetFinalData method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetFinalData(void) const;
 
    /// Reset FinalData data member.
    void ResetFinalData(void);
 
    /// Get the FinalData member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TFinalData& GetFinalData(void) const;
 
    /// Assign a value to FinalData data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetFinalData(TFinalData& value);
 
    /// Assign a value to FinalData data member.
    ///
    /// @return
    ///   Reference to the data value.
    TFinalData& SetFinalData(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CPssm_Base(const CPssm_Base&);
    CPssm_Base& operator=(const CPssm_Base&);
 
    // data
    Uint4 m_set_State[1];
    bool m_IsProtein;
    CRef< TIdentifier > m_Identifier;
    int m_NumRows;
    int m_NumColumns;
    list< string > m_RowLabels;
    bool m_ByRow;
    CRef< TQuery > m_Query;
    CRef< TIntermediateData > m_IntermediateData;
    CRef< TFinalData > m_FinalData;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CPssm_Base::IsSetIsProtein(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CPssm_Base::CanGetIsProtein(void) const
{
    return true;
}
 
inline
void CPssm_Base::ResetIsProtein(void)
{
    m_IsProtein = true;
    m_set_State[0] &= ~0x3;
}
 
inline
void CPssm_Base::SetDefaultIsProtein(void)
{
    ResetIsProtein();
}
 
inline
CPssm_Base::TIsProtein CPssm_Base::GetIsProtein(void) const
{
    return m_IsProtein;
}
 
inline
void CPssm_Base::SetIsProtein(CPssm_Base::TIsProtein value)
{
    m_IsProtein = value;
    m_set_State[0] |= 0x3;
}
 
inline
CPssm_Base::TIsProtein& CPssm_Base::SetIsProtein(void)
{
#ifdef _DEBUG
    if (!IsSetIsProtein()) {
        memset(&m_IsProtein,UnassignedByte(),sizeof(m_IsProtein));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_IsProtein;
}
 
inline
bool CPssm_Base::IsSetIdentifier(void) const
{
    return m_Identifier.NotEmpty();
}
 
inline
bool CPssm_Base::CanGetIdentifier(void) const
{
    return IsSetIdentifier();
}
 
inline
const CPssm_Base::TIdentifier& CPssm_Base::GetIdentifier(void) const
{
    if (!CanGetIdentifier()) {
        ThrowUnassigned(1);
    }
    return (*m_Identifier);
}
 
inline
bool CPssm_Base::IsSetNumRows(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CPssm_Base::CanGetNumRows(void) const
{
    return IsSetNumRows();
}
 
inline
void CPssm_Base::ResetNumRows(void)
{
    m_NumRows = 0;
    m_set_State[0] &= ~0x30;
}
 
inline
CPssm_Base::TNumRows CPssm_Base::GetNumRows(void) const
{
    if (!CanGetNumRows()) {
        ThrowUnassigned(2);
    }
    return m_NumRows;
}
 
inline
void CPssm_Base::SetNumRows(CPssm_Base::TNumRows value)
{
    m_NumRows = value;
    m_set_State[0] |= 0x30;
}
 
inline
CPssm_Base::TNumRows& CPssm_Base::SetNumRows(void)
{
#ifdef _DEBUG
    if (!IsSetNumRows()) {
        memset(&m_NumRows,UnassignedByte(),sizeof(m_NumRows));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_NumRows;
}
 
inline
bool CPssm_Base::IsSetNumColumns(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CPssm_Base::CanGetNumColumns(void) const
{
    return IsSetNumColumns();
}
 
inline
void CPssm_Base::ResetNumColumns(void)
{
    m_NumColumns = 0;
    m_set_State[0] &= ~0xc0;
}
 
inline
CPssm_Base::TNumColumns CPssm_Base::GetNumColumns(void) const
{
    if (!CanGetNumColumns()) {
        ThrowUnassigned(3);
    }
    return m_NumColumns;
}
 
inline
void CPssm_Base::SetNumColumns(CPssm_Base::TNumColumns value)
{
    m_NumColumns = value;
    m_set_State[0] |= 0xc0;
}
 
inline
CPssm_Base::TNumColumns& CPssm_Base::SetNumColumns(void)
{
#ifdef _DEBUG
    if (!IsSetNumColumns()) {
        memset(&m_NumColumns,UnassignedByte(),sizeof(m_NumColumns));
    }
#endif
    m_set_State[0] |= 0x40;
    return m_NumColumns;
}
 
inline
bool CPssm_Base::IsSetRowLabels(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CPssm_Base::CanGetRowLabels(void) const
{
    return true;
}
 
inline
const CPssm_Base::TRowLabels& CPssm_Base::GetRowLabels(void) const
{
    return m_RowLabels;
}
 
inline
CPssm_Base::TRowLabels& CPssm_Base::SetRowLabels(void)
{
    m_set_State[0] |= 0x100;
    return m_RowLabels;
}
 
inline
bool CPssm_Base::IsSetByRow(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CPssm_Base::CanGetByRow(void) const
{
    return true;
}
 
inline
void CPssm_Base::ResetByRow(void)
{
    m_ByRow = false;
    m_set_State[0] &= ~0xc00;
}
 
inline
void CPssm_Base::SetDefaultByRow(void)
{
    ResetByRow();
}
 
inline
CPssm_Base::TByRow CPssm_Base::GetByRow(void) const
{
    return m_ByRow;
}
 
inline
void CPssm_Base::SetByRow(CPssm_Base::TByRow value)
{
    m_ByRow = value;
    m_set_State[0] |= 0xc00;
}
 
inline
CPssm_Base::TByRow& CPssm_Base::SetByRow(void)
{
#ifdef _DEBUG
    if (!IsSetByRow()) {
        memset(&m_ByRow,UnassignedByte(),sizeof(m_ByRow));
    }
#endif
    m_set_State[0] |= 0x400;
    return m_ByRow;
}
 
inline
bool CPssm_Base::IsSetQuery(void) const
{
    return m_Query.NotEmpty();
}
 
inline
bool CPssm_Base::CanGetQuery(void) const
{
    return IsSetQuery();
}
 
inline
const CPssm_Base::TQuery& CPssm_Base::GetQuery(void) const
{
    if (!CanGetQuery()) {
        ThrowUnassigned(6);
    }
    return (*m_Query);
}
 
inline
bool CPssm_Base::IsSetIntermediateData(void) const
{
    return m_IntermediateData.NotEmpty();
}
 
inline
bool CPssm_Base::CanGetIntermediateData(void) const
{
    return IsSetIntermediateData();
}
 
inline
const CPssm_Base::TIntermediateData& CPssm_Base::GetIntermediateData(void) const
{
    if (!CanGetIntermediateData()) {
        ThrowUnassigned(7);
    }
    return (*m_IntermediateData);
}
 
inline
bool CPssm_Base::IsSetFinalData(void) const
{
    return m_FinalData.NotEmpty();
}
 
inline
bool CPssm_Base::CanGetFinalData(void) const
{
    return IsSetFinalData();
}
 
inline
const CPssm_Base::TFinalData& CPssm_Base::GetFinalData(void) const
{
    if (!CanGetFinalData()) {
        ThrowUnassigned(8);
    }
    return (*m_FinalData);
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJECTS_SCOREMAT_PSSM_BASE_HPP