Writer.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of YODA -- Yet more Objects for Data Analysis
// Copyright (C) 2008-2025 The YODA collaboration (see AUTHORS for details)
//
#ifndef YODA_Writer_h
#define YODA_Writer_h
 
#include "YODA/AnalysisObject.h"
#include "YODA/Utils/Traits.h"
 
#ifdef HAVE_HDF5
#include <YODA/Config/BuildConfig.h>
#ifdef WITH_HIGHFIVE
#include <YODA/highfive/H5File.hpp>
#else
#include <highfive/H5File.hpp>
#define YODA_H5 HighFive
#endif
#endif
 
#include <type_traits>
#include <fstream>
#include <iostream>
 
namespace YODA {
 
  static bool enableH5compression = Utils::getEnvParam("YODA_HDF5_COMPRESSION", true);
 
  class Writer {
  public:
 
    virtual ~Writer() {}
 
 
 
    void write(const std::string& filename, const AnalysisObject& ao);
 
    void write(std::ostream& stream, const AnalysisObject& ao) {
      std::vector<const AnalysisObject*> vec{&ao};
      write(stream, vec);
    }
 
    template <typename T>
    typename std::enable_if_t<DerefableToAO<T>::value> //< -> void if valid
    write(std::ostream& stream, const T& ao) {
      write(stream, *ao);
    }
 
    template <typename T>
    typename std::enable_if_t<DerefableToAO<T>::value> //< -> void if valid
    write(const std::string& filename, const T& ao) {
      write(filename, *ao);
    }
 
 
 
 
    #ifdef HAVE_HDF5
    void write(YODA_H5::File& file, const std::vector<const AnalysisObject*>& aos);
    #endif
 
    void write(std::ostream& stream, const std::vector<const AnalysisObject*>& aos, int precision = -1);
 
 
    template <typename RANGE>
    typename std::enable_if_t<CIterable<RANGE>::value>
    write(std::ostream& stream, const RANGE& aos) {
      write(stream, std::begin(aos), std::end(aos));
    }
 
    template <typename RANGE>
    typename std::enable_if_t<CIterable<RANGE>::value>
    write(const std::string& filename, const RANGE& aos) {
      write(filename, std::begin(aos), std::end(aos));
    }
 
 
 
 
    template <typename AOITER>
    void write(std::ostream& stream, const AOITER& begin, const AOITER& end, int precision = -1) {
      std::vector<const AnalysisObject*> vec;
      // vec.reserve(std::distance(begin, end));
      for (AOITER ipao = begin; ipao != end; ++ipao)  vec.push_back(&(**ipao));
      write(stream, vec, precision);
    }
 
 
    template <typename AOITER>
    void write(const std::string& filename, const AOITER& begin, const AOITER& end) {
      std::vector<const AnalysisObject*> vec;
      // vec.reserve(std::distance(begin, end));
      for (AOITER ipao = begin; ipao != end; ++ipao)  vec.push_back(&(**ipao));
 
      if (filename != "-") {
        try {
          const size_t lastdot = filename.find_last_of(".");
          std::string fmt = Utils::toLower(lastdot == std::string::npos ? filename : filename.substr(lastdot+1));
          const bool compress = (fmt == "gz") || (fmt == "h5" && enableH5compression);
          useCompression(compress);
          #ifdef HAVE_HDF5
          // check if the requested format is H5
          if (Utils::startswith(fmt, "h5")) {
            try {
              YODA_H5::File h5(filename, YODA_H5::File::OpenOrCreate | YODA_H5::File::Truncate);
              write(h5, vec);
            } catch(...) {
              throw WriteError("Failed to open HDF5 file " + filename);
            }
            return;
          }
          #endif
          // try writing to stream
          std::ofstream stream;
          stream.exceptions(std::ofstream::failbit | std::ofstream::badbit);
          stream.open(filename.c_str());
          if (stream.fail())
            throw WriteError("Writing to filename " + filename + " failed");
          write(stream, vec);
        } catch (std::ofstream::failure& e) {
          throw WriteError("Writing to filename " + filename + " failed: " + e.what());
        }
      } else {
        try {
          write(std::cout, vec);
        } catch (std::runtime_error& e) {
          throw WriteError("Writing to stdout failed: " + std::string(e.what()));
        }
      }
 
    }
 
 
    void setPrecision(int precision) {
      _precision = precision;
    }
 
    void setAOPrecision(const bool needsDP = false) {
      if (needsDP)             _aoprecision = std::numeric_limits<double>::max_digits10;
      else if (_precision > 0) _aoprecision = _precision;
      else                     _aoprecision = 6;
    }
 
    void useCompression(const bool compress=true) {
      _compress = compress;
    }
 
 
  protected:
 
 
    virtual void writeHead(std::ostream&) {}
 
    virtual void writeBody(std::ostream& stream, const AnalysisObject* ao);
 
    virtual void writeBody(std::ostream& stream, const AnalysisObject& ao);
 
    template <typename T>
    typename std::enable_if_t<DerefableToAO<T>::value> //< -> void if valid
    writeBody(std::ostream& stream, const T& ao) { writeBody(stream, *ao); }
 
    virtual void writeFoot(std::ostream& stream) { stream << std::flush; }
 
 
 
 
    virtual void writeAO(std::ostream& stream, const AnalysisObject& ao) = 0;
 
    #ifdef HAVE_HDF5
    virtual void writeAOS(YODA_H5::File& file, const vector<const AnalysisObject*>& aos) = 0;
    #endif
 
 
 
    int _precision, _aoprecision;
 
    bool _compress;
 
  };
 
 
  Writer& mkWriter(const std::string& format_name);
 
 
}
 
#endif