src/genome.h

/*****************************************************************************
* This file is provided under the Creative Commons Attribution 3.0 license.
*
* You are free to share, copy, distribute, transmit, or adapt this work
* PROVIDED THAT you attribute the work to the authors listed below.
* For more information, please see the following web page:
* http://creativecommons.org/licenses/by/3.0/
*
* This file is a component of the Sleipnir library for functional genomics,
* authored by:
* Curtis Huttenhower (chuttenh@princeton.edu)
* Mark Schroeder
* Maria D. Chikina
* Olga G. Troyanskaya (ogt@princeton.edu, primary contact)
*
* If you use this library, the included executable tools, or any related
* code in your work, please cite the following publication:
* Curtis Huttenhower, Mark Schroeder, Maria D. Chikina, and
* Olga G. Troyanskaya.
* "The Sleipnir library for computational functional genomics"
*****************************************************************************/
#ifndef GENOME_H
#define GENOME_H

#include <fstream>
#include <string>

#include "genomei.h"

namespace Sleipnir {

class CGenes;

class CGene : CGeneImpl {
public:
    CGene( const std::string& strID );

    bool AddSynonym( const std::string& strName );
    bool AddAnnotation( const IOntology* pOntology, size_t iTerm );
    bool SetWeight( float weight);
    bool IsAnnotated( const IOntology* pOntology ) const;
    bool IsAnnotated( const IOntology* pOntology, size_t iTerm ) const;

    const std::string& GetName( ) const {

        return m_strName; }

    size_t GetSynonyms( ) const {

        return m_iSynonyms; }

    const std::string& GetSynonym( size_t iSynonym ) const {

        return m_astrSynonyms[ iSynonym ]; }

    void SetGloss( const std::string& strGloss ) {

        m_strGloss = strGloss; }

    const std::string& GetGloss( ) const {

        return m_strGloss; }

    void SetDubious( bool fDubious ) {

        m_fDubious = fDubious; }

    bool GetDubious( ) const {

        return m_fDubious; }

    void SetRNA( bool fRNA ) {

        m_fRNA = fRNA; }

    bool GetRNA( ) const {

        return m_fRNA; }
    const float GetWeight() const {
        return m_weight; }
    size_t GetOntologies( ) const {

        return m_iOntologies; }

    const IOntology* GetOntology( size_t iOntology ) const {

        return m_apOntologies[ iOntology ]; }

    size_t GetAnnotations( size_t iOntology ) const {

        return m_apveciAnnotations[ iOntology ]->size( ); }

    size_t GetAnnotation( size_t iOntology, size_t iAnnotation ) const {

        return (*m_apveciAnnotations[ iOntology ])[ iAnnotation ]; }


};

class CGenome : CGenomeImpl {
public:
    bool Open( std::istream& istmFeatures );
    bool Open( const std::vector<std::string>& vecstrGenes );
    bool Open( const char* szFile, std::vector<CGenes*>& vecpGenes );
    bool Open( std::istream& istmGenes, std::vector<CGenes*>& vecpGenes );
    CGene& AddGene( const std::string& strID );
    size_t FindGene( const std::string& strGene ) const;
    std::vector<std::string> GetGeneNames( ) const;
    size_t CountGenes( const IOntology* pOntology ) const;
    bool AddSynonym( CGene& Gene, const std::string& strName );

    CGene& GetGene( size_t iGene ) const {

        return *m_vecpGenes[ iGene ]; }

    size_t GetGene( const std::string& strGene ) const {
        TMapStrI::const_iterator    iterGene;

        return ( ( ( iterGene = m_mapGenes.find( strGene ) ) == m_mapGenes.end( ) ) ? -1 :
            iterGene->second ); }

    size_t GetGenes( ) const {

        return m_vecpGenes.size( ); }
};

class CGenes : CGenesImpl {
public:
    static bool Open( const char* szFile, CGenome& Genome, std::vector<std::string>& vecstrNames, std::vector<CGenes*>& vecpGenes );

    CGenes( CGenome& Genome );

    bool Open( std::istream& istm, bool fCreate = true );
    bool Open( const std::vector<std::string>& vecstrGenes, bool fCreate = true );
    bool OpenWeighted( std::istream& istm, bool fCreate = true );
    void Filter( const CGenes& GenesExclude );
    size_t CountAnnotations( const IOntology* pOntology, size_t iTerm, bool fRecursive = true,
        const CGenes* pBackground = NULL ) const;
    std::vector<std::string> GetGeneNames( ) const;
    

    bool Open( const char* szFile, bool fCreate = true ) {
        std::ifstream   ifsm;

        ifsm.open( szFile );
        return ( ifsm.is_open( ) && Open( ifsm, fCreate ) ); }
    bool OpenWeighted( const char* szFile, bool fCreate = true ) {
        std::ifstream   ifsm;

        ifsm.open( szFile );
        return ( ifsm.is_open( ) && OpenWeighted( ifsm, fCreate ) ); }
    size_t GetGenes( ) const {

        return m_vecpGenes.size( ); }

    bool IsGene( const std::string& strGene ) const {

        return ( m_mapGenes.find( strGene ) != m_mapGenes.end( ) ); }
    bool IsWeighted() const {
        return isWeighted;}

    CGenome& GetGenome( ) const {

        return m_Genome; }

    const CGene& GetGene( size_t iGene ) const {

        return *m_vecpGenes[ iGene ]; }

    const float GetGeneWeight( size_t iGene ) const {
        if (iGene!=-1)
            return m_vecpGenes[ iGene ]->GetWeight(); 
        return 0;}
    size_t GetGene( const std::string& strGene ) const {
        TMapStrI::const_iterator    iterGene;

        return ( ( ( iterGene = m_mapGenes.find( strGene ) ) == m_mapGenes.end( ) ) ? -1 :
            iterGene->second ); }

    bool AddGene( const std::string& strGene ) {

        if( GetGene( strGene ) != -1 )
            return false;

        m_mapGenes[ strGene ] = m_vecpGenes.size( );
        m_vecpGenes.push_back( &m_Genome.AddGene( strGene ) );
        return true; }
};

}

#endif // GENOME_H