src/annotationmips.cpp

/*****************************************************************************
* 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"
*****************************************************************************/
#include "stdafx.h"
#include "annotation.h"
#include "genome.h"

namespace Sleipnir {

const char  COntologyMIPSImpl::c_szMIPS[]   = "MIPS";

COntologyMIPS::COntologyMIPS( ) {

    m_pOntology = this; }

COntologyMIPSImpl::SParserMIPS::SParserMIPS( std::istream& istm, CGenome& Genome ) :
    SParser( istm, Genome ) { }

COntologyMIPSImpl::COntologyMIPSImpl( ) : COntologyImpl( c_szMIPS ) { }

bool COntologyMIPS::Open( std::istream& istmOntology, std::istream& istmAnnotations, CGenome& Genome ) {
    SParserMIPS sParserOnto( istmOntology, Genome );
    SParserMIPS sParserGene( istmAnnotations, Genome );

    if( !OpenOntology( sParserOnto ) ) {
        g_CatSleipnir( ).error( "COntologyMIPS::Open( ) failed on ontology line %d: %s", sParserOnto.m_iLine,
            sParserOnto.m_szLine );
        return false; }
    if( !OpenGenes( sParserGene ) ) {
        g_CatSleipnir( ).error( "COntologyMIPS::Open( ) failed on genes line %d: %s", sParserGene.m_iLine,
            sParserGene.m_szLine );
        return false; }

    return true; }

bool COntologyMIPSImpl::OpenOntology( SParserMIPS& sParser ) {
    size_t                  i, j;
    vector<vector<size_t> > vecveciChildren;

    g_CatSleipnir( ).info( "COntologyMIPSImpl::OpenOntology( )" );
    if( !( sParser.GetLine( ) && ( sParser.m_szLine[ 0 ] == '#' ) && sParser.GetLine( ) ) )
        return false;

    while( sParser.m_istm.peek( ) != EOF )
        if( !OpenCategory( sParser ) )
            return false;
    if( !OpenCategory( sParser ) )
        return false;

    m_aNodes = new SNode[ m_iNodes = sParser.m_veciParents.size( ) ];
    vecveciChildren.resize( m_iNodes );
    for( i = 0; i < m_iNodes; ++i ) {
        m_aNodes[ i ].m_strID = sParser.m_vecstrIDs[ i ];
        m_mapNodes[ m_aNodes[ i ].m_strID ] = i;
        m_aNodes[ i ].m_strGloss = sParser.m_vecstrGlosses[ i ];
        if( sParser.m_veciParents[ i ] != -1 ) {
            m_aNodes[ i ].m_aiParents = new size_t[ m_aNodes[ i ].m_iParents = 1 ];
            m_aNodes[ i ].m_aiParents[ 0 ] = sParser.m_veciParents[ i ];
            vecveciChildren[ sParser.m_veciParents[ i ] ].push_back( i ); } }
    for( i = 0; i < m_iNodes; ++i ) {
        if( !vecveciChildren[ i ].size( ) )
            continue;
        m_aNodes[ i ].m_aiChildren = new size_t[ m_aNodes[ i ].m_iChildren =
            vecveciChildren[ i ].size( ) ];
        for( j = 0; j < m_aNodes[ i ].m_iChildren; ++j )
            m_aNodes[ i ].m_aiChildren[ j ] = vecveciChildren[ i ][ j ]; }

    return true; }

bool COntologyMIPSImpl::OpenCategory( SParserMIPS& sParser ) {
    char*   pch;
    size_t  i, iDepth;

    if( !( pch = strchr( sParser.m_szLine, ' ' ) ) )
        return false;

    *(pch++) = 0;
    sParser.m_vecstrIDs.push_back( sParser.m_szLine );
    while( *pch && isspace( *pch ) )
        pch++;
    sParser.m_vecstrGlosses.push_back( pch );
    if( ( iDepth = OpenID( sParser ) ) == -1 )
        return false;
    while( iDepth < sParser.m_stakiHier.size( ) )
        sParser.m_stakiHier.pop( );
    i = sParser.m_veciParents.size( );
    sParser.m_veciParents.push_back( sParser.m_stakiHier.empty( ) ? -1 :
        sParser.m_stakiHier.top( ) );
    if( iDepth >= sParser.m_stakiHier.size( ) )
        sParser.m_stakiHier.push( i );

    return sParser.GetLine( ); }

size_t COntologyMIPSImpl::OpenID( SParserMIPS& sParser ) {
    size_t  iRet;
    char*   pch;

    for( iRet = 0,pch = strchr( sParser.m_szLine, '.' ); pch; ++iRet,
        pch = strchr( ++pch, '.' ) );

    return iRet; }

bool COntologyMIPSImpl::OpenGenes( SParserMIPS& sParser ) {
    size_t  i, j;

    g_CatSleipnir( ).info( "COntologyMIPSImpl::OpenGenes( )" );
    if( !sParser.GetLine( ) )
        return false;
    if( !sParser.m_szLine[ 0 ] )
        return true;

    sParser.m_vecpGenes.resize( m_iNodes );
    while( sParser.m_istm.peek( ) != EOF )
        if( !OpenGene( sParser ) )
            return false;
    if( !OpenGene( sParser ) )
        return false;

    for( i = 0; i < m_iNodes; ++i ) {
        if( !sParser.m_vecpGenes[ i ].size( ) )
            continue;
        m_aNodes[ i ].m_apGenes = new const CGene*[ m_aNodes[ i ].m_iGenes =
            sParser.m_vecpGenes[ i ].size( ) ];
        for( j = 0; j < m_aNodes[ i ].m_iGenes; ++j )
            m_aNodes[ i ].m_apGenes[ j ] = sParser.m_vecpGenes[ i ][ j ]; }

    return true; }

bool COntologyMIPSImpl::OpenGene( SParserMIPS& sParser ) {
    char*   pchOne;
    char*   pchTwo;
    size_t  iNode;

    if( !( ( pchOne = strchr( sParser.m_szLine, '|' ) ) &&
        ( pchTwo = strchr( pchOne + 1, '|' ) ) ) )
        return false;
    *(pchOne++) = *pchTwo = 0;

    iNode = m_mapNodes[ pchOne ];
    {
        CGene&  Gene    = sParser.m_Genome.AddGene( sParser.m_szLine );

        Gene.AddAnnotation( m_pOntology, iNode );
        sParser.m_vecpGenes[ iNode ].push_back( &Gene );
    }

    return sParser.GetLine( ); }

const char  COntologyMIPSPhenotypes::c_szMIPSPhen[] = "MIPSP";

COntologyMIPSPhenotypes::COntologyMIPSPhenotypes( ) {

    m_pOntology = this;
    m_strID = c_szMIPSPhen; }

}