Reader.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_READER_H
#define YODA_READER_H
 
#include "YODA/Utils/ReaderUtils.h"
#include "YODA/Utils/Traits.h"
#include <memory>
#include <fstream>
#include <iostream>
#include <sstream>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
namespace YODA {
 
 
  class Reader {
 
  public:
 
    using TypeRegisterItr = typename std::unordered_map<std::string, std::unique_ptr<AOReaderBase>>::const_iterator;
 
    virtual ~Reader() {
      // This is technically leaking memory, but since this
      // is a (static) singleton, there should be no issue.
      // Cython relies on it for data-structure alignment, too.
      for (auto& aor : _register) { aor.second.release(); }
    }
 
 
 
    template<typename CONT>
    typename std::enable_if_t<YODA::Pushable<CONT,AnalysisObject*>::value>
    read(std::istream& stream, CONT& aos, const std::string& match = "", const std::string& unmatch = "") {
      // if CONT==std::vector<AnalysisObject*>, the compiler should select
      // the virtual method below, since it prefers non-templated methods in the lookup
      // otherwise we would enter a endless recursion. Check in case of problems.
      std::vector<AnalysisObject*> v_aos;
      read(stream, v_aos, match, unmatch);
      for (const AnalysisObject* ao : v_aos) aos.push_back(ao);
    }
 
    virtual void read(std::istream& stream, std::vector<AnalysisObject*>& aos,
                      const std::string& match = "", const std::string& unmatch = "") = 0;
 
    std::vector<AnalysisObject*> read(std::istream& stream, const std::string& match = "",
                                                            const std::string& unmatch = "") {
      std::vector<AnalysisObject*> rtn;
      read(stream, rtn, match, unmatch);
      return rtn;
    }
 
 
    template<typename CONT>
    typename std::enable_if_t<YODA::Pushable<CONT,AnalysisObject*>::value>
    read(const std::string& filename, CONT& aos, const std::string& match = "", const std::string& unmatch = "") {
      // if CONT==std::vector<AnalysisObject*>, the compiler should select
      // the virtual method below, since it prefers non-templated methods in the lookup
      // otherwise we would enter a endless recursion. Check in case of problems.
      std::vector<AnalysisObject*> v_aos;
      read(filename, v_aos, match, unmatch);
      for (const AnalysisObject* ao : v_aos) aos.push_back(ao);
    }
 
    void read(const std::string& filename, std::vector<AnalysisObject*>& aos, const std::string& match = "",
                                                                              const std::string& unmatch = "") {
      if (filename != "-") {
        try {
          std::ifstream instream;
          instream.open(filename.c_str());
          if (instream.fail())
            throw ReadError("Reading from filename " + filename + " failed");
          read(instream, aos, match, unmatch);
          instream.close();
        } catch (std::ifstream::failure& e) {
          throw ReadError("Reading from filename " + filename + " failed: " + e.what());
        }
      } else {
        try {
          read(std::cin, aos, match, unmatch);
        } catch (std::runtime_error& e) {
          throw ReadError("Reading from stdin failed: " + std::string(e.what()));
        }
      }
    }
 
    std::vector<AnalysisObject*> read(const std::string& filename, const std::string& match = "",
                                                                   const std::string& unmatch = "") {
      std::vector<AnalysisObject*> rtn;
      read(filename, rtn, match, unmatch);
      return rtn;
    }
 
 
 
    template<typename T>
    void registerType() {
      const string key = Utils::toUpper(T().type());
      const TypeRegisterItr& res = _register.find(key);
      if (res == _register.end())  _register[key] = std::make_unique<AOReader<T>>();
    }
 
    bool patternCheck(const std::string& path, const std::vector<std::regex>& patterns,
                                               const std::vector<std::regex>& unpatterns) {
      bool skip = false;
      if (patterns.size()) {
        skip = true;
        for (const std::regex& re : patterns) {
          if (std::regex_search(path, re)) { skip = false; break; }
        }
      }
      if (!skip && unpatterns.size()) {
        for (const std::regex& re : unpatterns) {
          if (std::regex_search(path, re)) { skip = true; break; }
        }
      }
      return !skip;
    }
 
 
    std::unordered_map<string, std::unique_ptr<AOReaderBase>> _register;
 
  };
 
 
  Reader& mkReader(const std::string& format_name);
 
 
}
 
#endif