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-2023 The YODA collaboration (see AUTHORS for details)
//
#ifndef YODA_Writer_h
#define YODA_Writer_h
 
#include "YODA/AnalysisObject.h"
#include "YODA/Utils/Traits.h"
#include <type_traits>
#include <fstream>
#include <iostream>
 
namespace YODA {
 
 
  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};
      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);
    }
 
 
 
 
    void write(std::ostream& stream, const std::vector<const AnalysisObject*>& aos);
 
 
    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) {
      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);
    }
 
 
    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");
          useCompression(compress);
          //
          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) {
      _aoprecision = needsDP? std::numeric_limits<double>::max_digits10 : _precision;
    }
 
    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;
 
 
 
    int _precision, _aoprecision;
 
    bool _compress;
 
  };
 
 
  Writer& mkWriter(const std::string& format_name);
 
 
}
 
#endif