CachedMzMLHandler.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Hannes Roest $
// $Authors: Hannes Roest $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/OPENSWATHALGO/DATAACCESS/ISpectrumAccess.h>
 
#include <OpenMS/KERNEL/StandardDeclarations.h>
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/Exception.h>
#include <OpenMS/CONCEPT/Macros.h>
 
#include <OpenMS/KERNEL/StandardTypes.h>
#include <OpenMS/CONCEPT/ProgressLogger.h>
 
#include <fstream>
 
#define CACHED_MZML_FILE_IDENTIFIER 8094
 
namespace OpenMS
{
 
namespace Internal
{
 
  class OPENMS_DLLAPI CachedMzMLHandler :
    public ProgressLogger
  {
    typedef int IntType;
    typedef double DoubleType;
 
public:
 
    typedef PeakMap MapType;
    typedef MSSpectrum SpectrumType;
    typedef MSChromatogram ChromatogramType;
 
    // using double precision to store all data (has to agree with type of BinaryDataArrayPtr)
    typedef double DatumSingleton;
 
    typedef std::vector<DatumSingleton> Datavector;
 
    CachedMzMLHandler();
 
    ~CachedMzMLHandler() override;
 
    CachedMzMLHandler& operator=(const CachedMzMLHandler& rhs);
 
 
    void writeMemdump(const MapType& exp, const String& out) const;
 
    void writeMetadata(MapType exp, const String& out_meta, bool addCacheMetaValue=false);
 
    void writeMetadata_x(const MapType& exp, const String& out_meta, bool addCacheMetaValue=false);
 
    void readMemdump(MapType& exp_reading, const String& filename) const;
 
    void createMemdumpIndex(const String& filename);
 
    const std::vector<std::streampos>& getSpectraIndex() const;
 
    const std::vector<std::streampos>& getChromatogramIndex() const;
 
 
    static inline void readSpectrumFast(OpenSwath::BinaryDataArrayPtr& data1,
                                        OpenSwath::BinaryDataArrayPtr& data2,
                                        std::ifstream& ifs, 
                                        int& ms_level,
                                        double& rt)
    {
      std::vector<OpenSwath::BinaryDataArrayPtr> data = readSpectrumFast(ifs, ms_level, rt);
      data1 = data[0];
      data2 = data[1];
    }
 
    static std::vector<OpenSwath::BinaryDataArrayPtr> readSpectrumFast(std::ifstream& ifs, int& ms_level, double& rt);
 
    static inline void readChromatogramFast(OpenSwath::BinaryDataArrayPtr& data1,
                                            OpenSwath::BinaryDataArrayPtr& data2, std::ifstream& ifs)
    {
      std::vector<OpenSwath::BinaryDataArrayPtr> data = readChromatogramFast(ifs);
      data1 = data[0];
      data2 = data[1];
    }
 
    static std::vector<OpenSwath::BinaryDataArrayPtr> readChromatogramFast(std::ifstream& ifs);
 
    static void readSpectrum(SpectrumType& spectrum, std::ifstream& ifs);
 
    static void readChromatogram(ChromatogramType& chromatogram, std::ifstream& ifs);
 
protected:
 
    void writeSpectrum_(const SpectrumType& spectrum, std::ofstream& ofs) const;
 
    void writeChromatogram_(const ChromatogramType& chromatogram, std::ofstream& ofs) const;
 
    static inline void readDataFast_(std::ifstream& ifs, std::vector<OpenSwath::BinaryDataArrayPtr>& data, const Size& data_size, 
      const Size& nr_float_arrays);
 
    std::vector<std::streampos> spectra_index_;
    std::vector<std::streampos> chrom_index_;
 
  };
}
}