io.h

Go to the documentation of this file.

/*
 * -------------------------------------------
 * Copyright (c) 2021 - 2024 Prashant K. Jha
 * -------------------------------------------
 * PeriDEM https://github.com/prashjha/PeriDEM
 *
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE)
 */
 
#ifndef UTILS_UTIL_IO_H
#define UTILS_UTIL_IO_H
 
#include "point.h"
#include "parallelUtil.h" // to make prints MPI aware
#include <fstream>
#include <iostream>
#include <vector>
#include <algorithm>
 
namespace util {
 
namespace io {
 
const int print_default_tab = 0;
 
const int print_default_mpi_rank = 0;
 
const int logger_default_debug_lvl = 5;
 
inline std::string getTabS(int nt) {
  std::string tabS = "";
  for (int i = 0; i < nt; i++)
    tabS += "\t";
 
  return tabS;
};
 
template <class T> inline std::string printStr(const T &msg, int nt = print_default_tab) {
 
  std::ostringstream oss;
  oss << getTabS(nt) << msg;
  return oss.str();
};
 
template <class T> inline std::string printStr(const std::vector<T> &list,
    int nt = print_default_tab) {
 
  auto tabS = getTabS(nt);
  std::ostringstream oss;
  oss << tabS;
  size_t i = 0;
  for (auto l : list) {
    oss << l;
    i++;
    if (i != list.size())
      oss << ", ";
  }
 
  return oss.str();
};
 
template <> inline std::string printStr(const std::vector<util::Point> &list,
                                               int nt) {
 
  auto tabS = getTabS(nt);
  std::ostringstream oss;
  oss << tabS;
  size_t i = 0;
  for (auto l : list) {
    oss << "(" << l[0] << ", " << l[1] << ", " << l[2] << ")";
    i++;
    if (i != list.size())
      oss << ", ";
  }
 
  return oss.str();
};
 
template <class T> inline void print(const T &msg, int nt = print_default_tab,
        int printMpiRank = print_default_mpi_rank) {
  if (printMpiRank < 0 or util::parallel::mpiRank() == printMpiRank)
    std::cout << printStr(msg, nt);
};
 
template <class T> inline void print(const std::vector<T> &list, int nt = print_default_tab,
        int printMpiRank = print_default_mpi_rank) {
  if (printMpiRank < 0 or util::parallel::mpiRank() == printMpiRank)
      std::cout << printStr(list, nt);
};
 
template <class T>
inline std::string printStr(const std::vector<std::vector<T>> &list,
                            int nt = print_default_tab) {
 
  auto tabS = getTabS(nt);
  std::ostringstream oss;
  oss << tabS;
  size_t i = 0;
  for (auto l : list) {
    oss << "(";
    for (size_t k = 0; k < l.size(); k++) {
      oss << l[k];
      if (k < l.size() - 1)
        oss << ", ";
    }
    oss << ")";
 
    i++;
    if (i != list.size())
      oss << ", ";
  }
 
  return oss.str();
}
 
template <class T> inline void print(const std::vector<std::vector<T>> &list,
        int nt = print_default_tab,
        int printMpiRank = print_default_mpi_rank) {
 
  if (printMpiRank < 0 or util::parallel::mpiRank() == printMpiRank)
    std::cout << printStr(list, nt);
};
 
inline std::string printBoxStr(const std::pair<util::Point, util::Point>
    &box, int nt = print_default_tab) {
  auto tabS = getTabS(nt);
  std::ostringstream oss;
  oss << tabS << "Corner point 1 = " << box.first.printStr(nt, 0) << std::endl;
  oss << tabS << "Corner point 2 = " << box.second.printStr(nt, 0) << std::endl;
 
  return oss.str();
};
 
inline void printBox(const std::pair<util::Point, util::Point> &box,
                     int nt = print_default_tab,
                     int printMpiRank = print_default_mpi_rank) {
    if (printMpiRank < 0 or util::parallel::mpiRank() == printMpiRank)
      std::cout << printBoxStr(box, nt);
};
 
inline std::string printBoxStr(const std::pair<std::vector<double>, std::vector<double>> &box,
                               int nt = print_default_tab) {
  auto tabS = getTabS(nt);
  std::ostringstream oss;
  oss << tabS << "Corner point 1 = (" << printStr<double>(box.first, 0)
              << ")" << std::endl;
  oss << tabS << "Corner point 2 = (" << printStr<double>(box.second, 0)
              << ")" << std::endl;
 
  return oss.str();
};
 
inline void printBox(const std::pair<std::vector<double>, std::vector<double>> &box,
                     int nt = print_default_tab, int printMpiRank = print_default_mpi_rank) {
  if (printMpiRank < 0 or util::parallel::mpiRank() == printMpiRank)
    std::cout << printBoxStr(box, nt);
};
 
struct LoggerDeck {
 
  int d_debugLevel;
 
  std::string d_filename;
 
  bool d_printScreen;
 
  bool d_printFile;
 
  LoggerDeck() : d_debugLevel(5), d_printScreen(true), d_printFile(false) {}
 
  LoggerDeck(int debug_level, std::string filename)
      : d_debugLevel(debug_level), d_filename(filename), d_printScreen
      (d_debugLevel > 0), d_printFile(!d_filename.empty()) {}
};
 
 
class Logger {
 
public:
 
  Logger(LoggerDeck *deck = nullptr) : d_deck_p(deck) {
 
    if (d_deck_p == nullptr)
      d_deck_p = new LoggerDeck();
  }
 
  ~Logger() {
 
    if (d_deck_p->d_printFile)
      d_logFile.close();
  }
 
  void log(std::ostringstream &oss, bool screen_out = false,
           int printMpiRank = print_default_mpi_rank) {
 
    log(oss.str(), screen_out, printMpiRank);
 
    // reset oss
    oss.str("");
    oss.clear();
  };
 
  void log(const std::string &str, bool screen_out = false,
           int printMpiRank = print_default_mpi_rank) {
 
    if (printMpiRank < 0 or util::parallel::mpiRank() == printMpiRank) {
      if (d_deck_p->d_printScreen || screen_out)
        std::cout << str << std::flush;
 
      // log
      if (d_deck_p->d_printFile) {
        d_logFile.open(d_deck_p->d_filename, std::ios_base::app);
        d_logFile << str;
        d_logFile.close();
      }
    }
  };
 
  LoggerDeck *d_deck_p;
 
  std::ofstream d_logFile;
};
 
void initLogger(int debug_level = logger_default_debug_lvl, std::string filename = "");
 
void log(std::ostringstream &oss, bool screen_out = false,
         int printMpiRank = print_default_mpi_rank);
 
void log(const std::string &str, bool screen_out = false,
         int printMpiRank = print_default_mpi_rank);
 
class InputParser {
public:
  InputParser(int &argc, char **argv) {
    for (int i = 1; i < argc; ++i)
    this->tokens.push_back(std::string(argv[i]));
  }
 
  const std::string &getCmdOption(const std::string &option) const {
    std::vector<std::string>::const_iterator itr;
    itr = std::find(this->tokens.begin(), this->tokens.end(), option);
    if (itr != this->tokens.end() && ++itr != this->tokens.end())
      return *itr;
 
    static const std::string empty_string("");
    return empty_string;
  }
 
  bool cmdOptionExists(const std::string &option) const {
    return std::find(this->tokens.begin(), this->tokens.end(), option) != this->tokens.end();
  }
 
private:
  std::vector<std::string> tokens;
};
 
inline std::string getFilenameFromPath(std::string const & path, std::string const & delims = "/\\")
{
  return path.substr(path.find_last_of(delims) + 1);
}
 
inline std::string removeExtensionFromFile(std::string const & filename)
{
  typename std::string::size_type const p(filename.find_last_of('.'));
  return p > 0 && p != std::string::npos ? filename.substr(0, p) : filename;
}
 
inline std::string getExtensionFromFile(std::string const & filename)
{
  typename std::string::size_type const p(filename.find_last_of('.'));
 
  //return filename.substr(p + 1);
  return p > 0 && p != std::string::npos ? filename.substr(p+1) : "";
}
 
inline std::string checkAndCreateNewFilename(std::string const & filename, std::string filename_ext)
{
  auto f_ext = util::io::getExtensionFromFile(filename);
  std::string f = filename;
  if (f_ext.empty()) {
    f = f + "." + filename_ext;
  }
  else {
    if (f_ext != filename_ext) {
      std::cerr << "checkAndCreateNewFilename(): Argument filename = "
                << filename << " has extension = "
                << f_ext << " which does not match expected extension = "
                << filename_ext << std::endl;
      exit(EXIT_FAILURE);
    }
  }
 
  return f;
}
 
inline bool isFileEmpty(std::string filename) {
  std::ifstream pFile(filename);
  return pFile.peek() == std::ifstream::traits_type::eof();
}
 
inline bool isFileEmpty(std::ifstream& pFile) {
  return pFile.peek() == std::ifstream::traits_type::eof();
}
 
} // namespace io
 
} // namespace util
 
#endif // UTILS_UTIL_IO_H