io.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// Copyright (C) 2021 CERN & University of Surrey for the benefit of the
// BioDynaMo collaboration. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//
// See the LICENSE file distributed with this work for details.
// See the NOTICE file distributed with this work for additional information
// regarding copyright ownership.
//
// -----------------------------------------------------------------------------
 
#ifndef CORE_UTIL_IO_H_
#define CORE_UTIL_IO_H_
 
#include <string>
#include <vector>
 
#include <TFile.h>
#include <TSystem.h>
#include "core/util/root.h"
 
namespace bdm {
 
class RuntimeVariables {
 public:
  RuntimeVariables();
  // Constructor for ROOT I/O
  explicit RuntimeVariables(TRootIOCtor* io_ctor);
 
  SysInfo_t GetSystemInfo() const;
  void SetSystemInfo(const SysInfo_t& other);
 
  void PrintSystemInfo() const;
 
  bool operator==(const RuntimeVariables& other) const;
 
  bool operator!=(const RuntimeVariables& other) const;
 
 private:
  SysInfo_t sysinfo_;
  BDM_CLASS_DEF_NV(RuntimeVariables, 1);  // NOLINT
};
 
class TFileRaii {
 public:
  TFileRaii(const std::string& filename, const char* mode);
  explicit TFileRaii(TFile* file);
  ~TFileRaii();
  TFile* Get();
 
 private:
  TFile* file_;
};
 
template <typename T>
class IntegralTypeWrapper {
 public:
  explicit IntegralTypeWrapper(const T& data) : data_(data) {}
  explicit IntegralTypeWrapper(TRootIOCtor* io_ctor) {}
  const T& Get() const { return data_; }
 
 private:
  T data_;
  BDM_CLASS_DEF_NV(IntegralTypeWrapper, 1);
};
 
template <typename T>
class VectorTypeWrapper {
 public:
  VectorTypeWrapper() = default;
 
  std::vector<T> vector_;
  ClassDefNV(VectorTypeWrapper, 1);
};
 
bool FileExists(const std::string& file_name);
 
void WriteToFile(const std::string& filename, const std::string& content);
 
template <typename T>
bool GetPersistentObject(const char* root_file, const char* obj_name,
                         T*& empty_obj) {  // NOLINT
  if (FileExists(root_file)) {
    TFileRaii file(TFile::Open(root_file));
    file.Get()->GetObject(obj_name, empty_obj);
    return true;
  }
  return false;
}
 
// clang-format off
// clang-format on
template <typename T>
void WritePersistentObject(const char* root_file, const char* obj_name,
                           const T& pst_object, const char* mode = "new") {
  TFileRaii file(root_file, mode);
  file.Get()->WriteObject(&pst_object, obj_name);
}
 
}  // namespace bdm
 
#endif  // CORE_UTIL_IO_H_