kome::io::mzml::MzmlHandler Class Reference

XML handler class to read mzML file. More...

#include <MzmlHandler.h>

Inheritance diagram for kome::io::mzml::MzmlHandler:

Collaboration diagram for kome::io::mzml::MzmlHandler:

Classes
struct	SpecInfo
	spectrum information More...

Public Member Functions
	MzmlHandler (MzmlSample &file)
	constructor More...
virtual	~MzmlHandler ()
	destructor

Protected Types
enum	ArrayType { TYPE_OTHER, TYPE_MZ, TYPE_RT, TYPE_INT }
	array data type

Protected Member Functions
SpecInfo *	getSpecInfo (const char *name)
	gets the spectrum information More...
void	setSpecInfo (kome::objects::Spectrum *spec, SpecInfo *info)
	sets the spectrum information More...
virtual void	onStartDocument ()
	This method is called by startDocument method. (override method)
virtual void	onEndDocument ()
	This method is called by endDocument method. (override method)
virtual void	onStartElement (const char *name, kome::core::Properties &attrs)
	This method is called by startElement method. (override method) More...
virtual void	onEndElement (const char *name, const char *text)
	This method is called by end element method. (override method) More...

Protected Attributes
MzmlSample &	m_file
Accession *	m_machineAcc
Accession *	m_arrAcc
Accession *	m_specAcc
Accession *	m_softwareAcc
long long	m_pos
MzmlSpectrum *	m_currSpec
MzmlChromatogram *	m_currChrom
ArrayType	m_currType
MzmlSample::ArrayInfo	m_arrayInfo
int	m_scanNum
std::map< std::string, SpecInfo >	m_specMap
SpecInfo *	m_currSpecInfo
std::string	m_currSoftwareName
std::string	m_currSoftwareVersion
bool	m_inIonTag
bool	m_inPrecursor
bool	m_inProduct
std::map< std::string, MzmlSpectrum * >	m_specIdMap
std::map< int, MzmlSpectrum * >	m_specScanMap
std::map< std::string, MzmlChromatogram * >	m_chromIdMap
int	m_offsetScan
std::string	m_offsetId

Detailed Description

XML handler class to read mzML file.

Definition at line 33 of file MzmlHandler.h.

Constructor & Destructor Documentation

kome::io::mzml::MzmlHandler::MzmlHandler

(

MzmlSample &

file

)

constructor

Parameters

file	mzML file object

Definition at line 78 of file MzmlHandler.cpp.

                                           : m_file( file ) {
    // initialize
    onStartDocument();

    // accessions
    AccessionManager& accManager = AccessionManager::getInstance();

    m_machineAcc = accManager.getAccession( MACHINE_ACC );
    m_arrAcc = accManager.getAccession( ARRAY_ACC );
    m_specAcc = accManager.getAccession( SPEC_TYPE_ACC );
    m_softwareAcc = accManager.getAccession( SOFTWARE_ACC );
}

Here is the call graph for this function:

Member Function Documentation

SpecInfo * kome::io::mzml::MzmlHandler::getSpecInfo ( const char *  name )

protected

gets the spectrum information

Parameters

[in]

name

spectrum name

Returns

spectrum information

Definition at line 96 of file MzmlHandler.cpp.

                                                                {
    // name
    std::string n = trimstring( name );

    // spec info
    bool iniFlg = ( m_specMap.find( n ) == m_specMap.end() );
    SpecInfo* s = &( m_specMap[ n ] );

    // initialize
    if( iniFlg ) {
        s->stage = -1;
        s->centroid = -1;
        s->polarity = kome::objects::Spectrum::POLARITY_UNKNOWN;
        s->mzLowerLimit = -1.0;
        s->mzUpperLimit = -1.0;
        s->tic = -1.0;
        s->bpm = -1.0;
        s->bpi = -1.0;
        s->rt = -1.0;
        s->prec = -1.0;
        s->props.clear();
        s->collisionEnergy.clear();
    }

    return s;
}

void kome::io::mzml::MzmlHandler::onEndElement ( const char *  name, const char *  text  )

protectedvirtual

This method is called by end element method. (override method)

Parameters

name	tag name
text	body text

Definition at line 561 of file MzmlHandler.cpp.

                                                                   {
    // each tags
    if( strcmp( name, SOFTWARE_TAG_NAME ) == 0 ) {  // </software>
        if( strlen( m_file.getSoftwareName() ) == 0 ) {
            m_file.setSoftwareName( m_currSoftwareName.c_str() );
            m_file.setSoftwareVersion( m_currSoftwareVersion.c_str() );
        }
        m_currSoftwareName.clear();
        m_currSoftwareVersion.clear();
    }
    else if( strcmp( name, SPEC_TAG_NAME ) == 0 ) { // </spectrum>
        m_currSpec = NULL;
    }
    else if( strcmp( name, CHROM_TAG_NAME ) == 0 ) {    // </chromatogram>
        if( m_currChrom != NULL ) {
            double q1 = m_currChrom->getQ1();
            double q3 = m_currChrom->getQ3();

            if( q1 >= 0.0 && q3 >= 0.0 ) {
                m_currChrom->setIcon( "MRM_chrom" );
            }
        }
        m_currChrom = NULL;
    }
    else if( strcmp( name, PARAM_GROUP_TAG_NAME ) == 0 ) {  // </referenceableParamGroup>
        if( m_currType != TYPE_OTHER ) {
            m_file.addArrayInfo(
                m_arrayInfo.name.c_str(),
                m_arrayInfo.bits,
                m_arrayInfo.compressed,
                m_arrayInfo.scale, m_arrayInfo.isY
            );
        }

        m_currSpecInfo = getSpecInfo( NULL );
    }
    else if( strcmp( name, ION_SELECTION_TAG_NAME ) == 0 ) {    // </ionSelection>
        m_inIonTag = false;
    }
    else if( strcmp( name, PRECURSOR_TAG_NAME ) == 0 ) {    // </precursor>
        m_inPrecursor = false;
    }
    else if( strcmp( name, PRODUCT_TAG_NAME ) == 0 ) {    // </product>
        m_inProduct = false;
    }
    else if( strcmp( name, OFFSET_TAG_NAME ) == 0 ) {   // </offset>
        // offset
        long long offset = toint64( text, 10, -1 );

        // get object
        MzmlSpectrum* spec = NULL;
        MzmlChromatogram* chrom = NULL;

        if( m_offsetScan >= 0 && m_specScanMap.find( m_offsetScan ) != m_specScanMap.end() ) {
            spec = m_specScanMap[ m_offsetScan ];
        }
        if( m_specIdMap.find( m_offsetId ) != m_specIdMap.end() ) {
            spec = m_specIdMap[ m_offsetId ];
        }
        if( m_chromIdMap.find( m_offsetId ) != m_chromIdMap.end() ) {
            chrom = m_chromIdMap[ m_offsetId ];
        }

        // set offset
        if( spec != NULL ) {
            spec->setOffset( offset );
        }
        if( chrom != NULL ) {
            chrom->setOffset( offset );
        }

        // initialize offset values
        m_offsetScan = -1;
        m_offsetId.clear();
    }

    // position
    m_pos = getPosition();
}

Here is the call graph for this function:

void kome::io::mzml::MzmlHandler::onStartElement ( const char *  name, kome::core::Properties &  attrs  )

protectedvirtual

This method is called by startElement method. (override method)

Parameters

name	tag name
attrs	attributes

Definition at line 198 of file MzmlHandler.cpp.

                                                                              {
    // each tags
    if( strcmp( name, CVPARAM_TAG_NAME ) == 0 ) {   // <cvParam>
        const char* a = attrs.getStringValue( CV_ACC_ATTR_NAME, "" );
        const char* n = attrs.getStringValue( CV_NAME_ATTR_NAME, "" );
        const char* v = attrs.getStringValue( CV_VALUE_ATTR_NAME, "" );

        if( strcmp( a, "MS:1000511" ) == 0 ) {  // ms level
            int stage = toint( v, 10, 1 );
            if( m_currSpec == NULL ) {
                m_currSpecInfo->stage = stage;
            }
            else {
                m_currSpec->setMsStage( stage );
            }
        }
        else if( strcmp( a, "MS:1000521" ) == 0 ) { // 32-bit float
            m_arrayInfo.bits = 32;
        }
        else if( strcmp( a, "MS:1000523" ) == 0 ) { // 64-bit float
            m_arrayInfo.bits = 64;
        }
        else if( strcmp( a, "MS:1000576" ) == 0 ) { // no compression
            m_arrayInfo.compressed = false;
        }
        else if( strcmp( a, "MS:1000574" ) == 0 ) { // zlib compression
            m_arrayInfo.compressed = true;
        }
        else if( strcmp( a, "MS:1000127" ) == 0 ) { // centroid spectrum
            if( m_currSpec == NULL ) {
                m_currSpecInfo->centroid = 1;
            }
            else {
                m_currSpec->setCentroidMode( true );
            }
        }
        else if( strcmp( a, "MS:1000128" ) == 0 ) { // profile spectrum
            if( m_currSpec == NULL ) {
                m_currSpecInfo->centroid = 0;
            }
            else {
                m_currSpec->setCentroidMode( false );
            }
        }
        else if( strcmp( a, "MS:1000129" ) == 0 ) { // negative scan
            if( m_currSpec == NULL ) {
                m_currSpecInfo->polarity = kome::objects::Spectrum::POLARITY_NEGATIVE;
            }
            else {
                m_currSpec->setPolarity( kome::objects::Spectrum::POLARITY_NEGATIVE );
            }
        }
        else if( strcmp( a, "MS:1000130" ) == 0 ) { // positive scan
            if( m_currSpec == NULL ) {
                m_currSpecInfo->polarity = kome::objects::Spectrum::POLARITY_POSITIVE;
            }
            else {
                m_currSpec->setPolarity( kome::objects::Spectrum::POLARITY_POSITIVE );
            }
        }
        else if( strcmp( a, "MS:1000501" ) == 0 ) { // scan m/z lower limit
            double lowMz = todouble( v, -1.0 );
            if( m_currSpec == NULL ) {
                m_currSpecInfo->mzLowerLimit = lowMz;
            }
            else {
                m_currSpec->setMinX( lowMz );
            }
        }
        else if( strcmp( a, "MS:1000500" ) == 0 ) { // scan m/z upper limit
            double upMz = todouble( v, -1.0 );
            if( m_currSpec == NULL ) {
                m_currSpecInfo->mzUpperLimit = upMz;
            }
            else {
                m_currSpec->setMaxX( upMz );
            }
        }
        else if( strcmp( a, "MS:1000285" ) == 0 ) { // total ion current
            double tic = todouble( v, -1.0 );
            if( m_currSpec == NULL ) {
                m_currSpecInfo->tic = tic;
            }
            else {
                m_currSpec->setTotalIntensity( tic );
            }
        }
        else if( strcmp( a, "MS:1000504" ) == 0 ) { // base peak m/z
            double bpm = todouble( v, -1.0 );
            if( m_currSpec == NULL ) {
                m_currSpecInfo->bpm = bpm;
            }
            else {
                m_currSpec->setBasePeakMass( bpm );
            }
        }
        else if( strcmp( a, "MS:1000505" ) == 0 ) { // base peak intensity
            double bpi = todouble( v, -1.0 );
            if( m_currSpec == NULL ) {
                m_currSpecInfo->bpi = bpi;
            }
            else {
                m_currSpec->setMaxIntensity( bpi );
            }
        }
        else if( strcmp( a, "MS:1000016" ) == 0 ) { // scan start time
            double rt = todouble( v, -1.0 );
            const char* unit = attrs.getStringValue( CV_UNIT_ATTR_NAME, "" );
            if( strcmp( unit, "UO:0000031" ) != 0 ) {   // second
                rt /= 60.0;
            }

            if( m_currSpec == NULL ) {
                m_currSpecInfo->rt = rt;
            }
            else {
                m_currSpec->setRt( rt );
                m_currSpec->setHasChromatogram( true );
            }
        }
        else if( strcmp( a, "MS:1000744" ) == 0 ) { // selected ion m/z
            double prec = todouble( v, -1.0 );
            if( m_currSpec == NULL ) {
                m_currSpecInfo->prec = prec;
            }
            else {
                m_currSpec->setPrecursor( prec );
            }
        }
        else if( strcmp( a, "MS:1000512" ) == 0 ) { // filter string
            if( m_currSpec == NULL ) {
                m_currSpecInfo->props.push_back( std::make_pair( "Filter", v ) );
            }
            else {
                m_currSpec->getProperties().setValue( "Filter", v );
            }
        }
        else if( strcmp( a, "MS:1000040" ) == 0 ) { // m/z
            double mz = todouble( v, -1.0 );
            if( m_inIonTag && m_currSpec != NULL ) {
                m_currSpec->setPrecursor( mz );
            }
        }
        else if( strcmp( a, "MS:1000827" ) == 0 ) {    // isolation window target m/z
            if( m_currSpec != NULL || m_currSpecInfo != NULL ) {    // spectrum
                std::string name = "Isolation Window Target m/z";
                if( m_inPrecursor ) {
                    name = "Precursor Target";
                }
                if( m_inProduct ) {
                    name = "Product Target";
                }

                if( m_currSpec == NULL ) {
                    m_currSpecInfo->props.push_back( std::make_pair( name.c_str(), v ) );
                }
                else {
                    m_currSpec->getProperties().setValue( name.c_str(), v );
                }
            }

            if( m_currChrom != NULL ) {    // chromatogram
                double mz = todouble( v, -1.0 );
                if( mz >= 0.0 ) {
                    if( m_inPrecursor ) {
                        m_currChrom->setQ1( mz );
                    }
                    else if( m_inProduct ) {
                        m_currChrom->setQ3( mz );
                    }
                }
            }
        }
        else if( strcmp( a, "MS:1000045" ) == 0 ) {
            const char* unitId = attrs.getStringValue( "unitAccession", "" );
            std::string ce = v;
            if( strcmp( unitId, "UO:0000266" ) == 0 ) {
                ce = FMT( "%s eV", v );
            }
            if( m_currSpec == NULL ) {
                m_currSpecInfo->collisionEnergy = ce;
            }
            else {
                m_currSpec->setCollisionEnergy( ce.c_str() );
            }
        }
        else {
            // accession
            AccessionManager& accManager = AccessionManager::getInstance();
            Accession* acc = accManager.getAccession( a );

            // parent
            Accession* parent = ( acc == NULL ? NULL : acc->getOrigin() );

            // each accessions
            if( parent == m_machineAcc ) {  // machine name
                m_file.setInstrument( n );
            }
            else if( parent == m_arrAcc ) { // array type
                // unit scale size
                const char* u = attrs.getStringValue( CV_UNIT_ATTR_NAME, "" );
                m_arrayInfo.isY = false;

                // set type
                if( strcmp( a, MZ_ARRAY_ACC ) == 0 ) {
                    m_currType = TYPE_MZ;
                }
                else if( strcmp( a, RT_ARRAY_ACC ) == 0 ) {
                    m_currType = TYPE_RT;
                    if( strcmp( u, "UO:0000031" ) != 0 ) {  // second
                        m_arrayInfo.scale = 1.0 / 60.0;
                    }
                }
                else if( strcmp( a, INT_ARRAY_ACC ) == 0 ) {
                    m_currType = TYPE_INT;
                    m_arrayInfo.isY = true;
                }
                else {
                    m_currType = TYPE_OTHER;
                }
            }
            else if( parent == m_specAcc ) {    // spectrum type
                if( m_currSpec == NULL ) {
                    m_currSpecInfo->props.push_back( std::make_pair( "Spectrum Type", n ) );
                }
                else {
                    m_currSpec->getProperties().setValue( "Spectrum Type", n );
                }
            }
            else if( parent == m_softwareAcc ) {    // software
                m_currSoftwareName = acc->getName();
            }
        }
    }
    else if( strcmp( name, SRC_FILE_TAG_NAME ) == 0 ) { // <sourceFile>
        // add source file
        std::string file = attrs.getStringValue( SRC_FILE_ATTR_NAME, "" );
        std::string location = attrs.getStringValue( SRC_LOC_ATTR_NAME, "" );

        if( !location.empty() ) {
            if( location[ (int)location.length() - 1 ] != '/' ) {
                location.append( "/" );
            }
        }
        location.append( file );

        m_file.addParentFile( location.c_str() );
    }
    else if( strcmp( name, SOFTWARE_TAG_NAME ) == 0 ) { // <software>       
        m_currSoftwareName = attrs.getStringValue( SOFTWARE_ID_ATTR_NAME, "" );
        m_currSoftwareVersion = attrs.getStringValue( SOFTWARE_VER_ATTR_NAME, "" );
    }
    else if( strcmp( name, PARAM_GROUP_TAG_NAME ) == 0 ) {  // <referenceableParamGroup>
        m_arrayInfo.name = attrs.getStringValue( PARAM_GROUP_ID_ATTR_NAME, "" );
        m_arrayInfo.bits = 32;
        m_arrayInfo.compressed = false;
        m_arrayInfo.scale = 1.0;
        m_arrayInfo.isY = false;

        m_currType = TYPE_OTHER;

        m_currSpecInfo = getSpecInfo( m_arrayInfo.name.c_str() );
    }
    else if( strcmp( name, SPEC_TAG_NAME ) == 0 ) { // <spectrum>
        // spectrum
        const char* id = attrs.getStringValue( SPEC_ID_ATTR_NAME, "Scan" );
        m_currSpec = new MzmlSpectrum( &m_file, id );
        m_specIdMap[ id ] = m_currSpec;
        long long pos = m_pos;
        if( pos > 0 ) {
            m_currSpec->setOffset( pos );
        }

        m_file.getRootDataGroupNode()->addSpectrum( m_currSpec );

        // default attributes
        SpecInfo* dfSpec = getSpecInfo( NULL );
        setSpecInfo( m_currSpec, dfSpec );

        // set attributes
        int scanNum = attrs.getIntValue( SPEC_SCAN_NUM_ATTR_NAME, m_scanNum );
        m_scanNum++;
        m_currSpec->setScanNumber( scanNum );
        m_specScanMap[ scanNum ] = m_currSpec;

        int stage = attrs.getIntValue( SPEC_MS_LEVEL_ATTR_NAME, dfSpec->stage );
        if( stage >= 1 ) {
            m_currSpec->setMsStage( stage );
        }

        std::string strSpotID = attrs.getStringValue( "spotID", "" );
        if  ( !strSpotID.empty( ) )
        {
            m_currSpec->setSpotId( strSpotID.c_str( ) );
        }
    }
    else if( strcmp( name, PRECURSOR_TAG_NAME ) == 0 ) {    // <precursor>
        // parent
        const char* id = attrs.getStringValue( PREC_SPEC_ATTR_NAME, NULL );
        kome::objects::Spectrum* parent = NULL;

        if( id != NULL && m_currSpec != NULL ) {
            if( m_specIdMap.find( id ) != m_specIdMap.end() ) {
                parent = m_specIdMap[ id ];
            }

            m_currSpec->setParentSpectrum( parent );
        }

        m_inPrecursor = true;
    }
    else if( strcmp( name, PRODUCT_TAG_NAME ) == 0 ) {    // <product>
        m_inProduct = true;
    }
    else if( strcmp( name, CHROM_TAG_NAME ) == 0 ) {    // <chromatogram>
        // chromatogram
        const char* id = attrs.getStringValue( CHROM_ID_ATTR_NAME, "Chromatogram" );
        m_currChrom = new MzmlChromatogram( &m_file );
        m_currChrom->setName( id );
        m_chromIdMap[ id ] = m_currChrom;

        m_file.getRootDataGroupNode()->addChromatogram( m_currChrom );
    }
    else if( strcmp( name, ION_SELECTION_TAG_NAME ) == 0 ) {    // <ionSelection>
        m_inIonTag = true;
    }
    else if( strcmp( name, USR_PARAM_TAG_NAME ) == 0 ) {    // <userParam>
        // name & value
        std::string n = attrs.getStringValue( USR_PARAM_NAME_ATTR_NAME, "" );
        std::string v = attrs.getStringValue( USR_PARAM_VAL_ATTR_NAME, "" );

        // SPEC No.86058 File Name is "Err!" �@@date 2012.06.11 <Mod> M.Izumi ->
        // properties
        kome::core::Properties* props = &m_file.getRootDataGroupNode()->getProperties();
        if( m_currSpec != NULL ) {
            props = &m_currSpec->getProperties();
        }
        if( m_currChrom != NULL ) {
            props = &m_currChrom->getProperties();
        }

        // add
        if( !n.empty() ) {
            props->setValue( n.c_str(), v.c_str() );
        }
        // <- @date 2012.06.11 <Mod> M.Izum
    }
    else if( strcmp( name, OFFSET_TAG_NAME ) == 0 ) {   // <offset>
        m_offsetScan = attrs.getIntValue( OFFSET_SCAN_ATTR_NAME, -1 );
        m_offsetId = attrs.getStringValue( OFFSET_IDREF_ATTR_NAME, "" );
    }
    else if( strcmp( name, REF_TAG_NAME ) == 0 ) {    // <referenceableParamGroupRef>
        std::string id = attrs.getStringValue( REF_REF_ATTR_NAME, "" );

        if( m_currSpec != NULL ) {
            SpecInfo* info = getSpecInfo( id.c_str() );

            setSpecInfo( m_currSpec, info );
        }
    }
}

Here is the call graph for this function:

void kome::io::mzml::MzmlHandler::setSpecInfo ( kome::objects::Spectrum *  spec, SpecInfo *  info  )

protected

sets the spectrum information

Parameters

[out]	spec	spectrum object
[in]	info	spectrum information

Definition at line 124 of file MzmlHandler.cpp.

                                                                         {
    if( info->stage > 0 ) {
        spec->setMsStage( info->stage );
    }

    if( info->centroid == 0 || info->centroid == 1 ) {
        spec->setCentroidMode( info->centroid == 1 );
    }

    if( info->polarity != kome::objects::Spectrum::POLARITY_UNKNOWN ) {
        spec->setPolarity( info->polarity );
    }

    if( info->mzLowerLimit >= 0.0 ) {
        spec->setMinX( info->mzLowerLimit );
    }

    if( info->mzUpperLimit >= 0.0 ) {
        spec->setMaxX( info->mzUpperLimit );
    }

    if( info->tic >= 0.0 ) {
        spec->setTotalIntensity( info->tic );
    }

    if( info->bpi >= 0.0 ) {
        spec->setMaxIntensity( info->bpi );
    }

    if( info->prec >= 0.0 ) {
        spec->setPrecursor( info->prec );
    }

    if( !info->collisionEnergy.empty() ) {
        spec->setCollisionEnergy( info->collisionEnergy.c_str() );
    }

    for( unsigned int i = 0; i < info->props.size(); i++ ) {
        spec->getProperties().setValue( info->props.at( i ).first.c_str(), info->props.at( i ).second.c_str() );
    }
}

Member Data Documentation

Accession* kome::io::mzml::MzmlHandler::m_arrAcc

protected

array accession

Definition at line 57 of file MzmlHandler.h.

MzmlSample::ArrayInfo kome::io::mzml::MzmlHandler::m_arrayInfo

protected

current array information

Definition at line 90 of file MzmlHandler.h.

std::map< std::string, MzmlChromatogram* > kome::io::mzml::MzmlHandler::m_chromIdMap

protected

chromatogram ID map

Definition at line 146 of file MzmlHandler.h.

MzmlChromatogram* kome::io::mzml::MzmlHandler::m_currChrom

protected

current chromaotgram

Definition at line 84 of file MzmlHandler.h.

std::string kome::io::mzml::MzmlHandler::m_currSoftwareName

protected

current software name

Definition at line 123 of file MzmlHandler.h.

std::string kome::io::mzml::MzmlHandler::m_currSoftwareVersion

protected

current software version

Definition at line 126 of file MzmlHandler.h.

MzmlSpectrum* kome::io::mzml::MzmlHandler::m_currSpec

protected

current spectrum

Definition at line 81 of file MzmlHandler.h.

SpecInfo* kome::io::mzml::MzmlHandler::m_currSpecInfo

protected

current spectrum information

Definition at line 119 of file MzmlHandler.h.

ArrayType kome::io::mzml::MzmlHandler::m_currType

protected

current array type

Definition at line 87 of file MzmlHandler.h.

MzmlSample& kome::io::mzml::MzmlHandler::m_file

protected

mzML file

Definition at line 50 of file MzmlHandler.h.

bool kome::io::mzml::MzmlHandler::m_inIonTag

protected

in ion tag flag

Definition at line 130 of file MzmlHandler.h.

bool kome::io::mzml::MzmlHandler::m_inPrecursor

protected

in precursor

Definition at line 133 of file MzmlHandler.h.

bool kome::io::mzml::MzmlHandler::m_inProduct

protected

in product

Definition at line 136 of file MzmlHandler.h.

Accession* kome::io::mzml::MzmlHandler::m_machineAcc

protected

machine accession

Definition at line 54 of file MzmlHandler.h.

std::string kome::io::mzml::MzmlHandler::m_offsetId

protected

offset ID

Definition at line 152 of file MzmlHandler.h.

int kome::io::mzml::MzmlHandler::m_offsetScan

protected

offset scan number

Definition at line 149 of file MzmlHandler.h.

long long kome::io::mzml::MzmlHandler::m_pos

protected

position

Definition at line 66 of file MzmlHandler.h.

int kome::io::mzml::MzmlHandler::m_scanNum

protected

scan number

Definition at line 94 of file MzmlHandler.h.

Accession* kome::io::mzml::MzmlHandler::m_softwareAcc

protected

software accession

Definition at line 63 of file MzmlHandler.h.

Accession* kome::io::mzml::MzmlHandler::m_specAcc

protected

spectrum type accession

Definition at line 60 of file MzmlHandler.h.

std::map< std::string, MzmlSpectrum* > kome::io::mzml::MzmlHandler::m_specIdMap

protected

spectrum ID map

Definition at line 140 of file MzmlHandler.h.

std::map< std::string, SpecInfo > kome::io::mzml::MzmlHandler::m_specMap

protected

spectrum map

Definition at line 116 of file MzmlHandler.h.

std::map< int, MzmlSpectrum* > kome::io::mzml::MzmlHandler::m_specScanMap

protected

scan map

Definition at line 143 of file MzmlHandler.h.

---

The documentation for this class was generated from the following files:

• MzmlIOPlugin/MzmlHandler.h
• MzmlIOPlugin/MzmlHandler.cpp