io.h

Go to the documentation of this file.

/*
 * -------------------------------------------
 * Copyright (c) 2021 - 2026 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 "util/io.h"
#include <stdexcept>
#include "constants.h"
#include "logger.h"
#include <fstream>
#include <sstream>
#include <iostream>
#include <vector>
#include <algorithm>
#include <format>
#include <string>
#include <map>
#include <string_view>
 
// includes for files that include this file
#include "inputParser.h"
 
namespace util {
 
namespace io {
 
class Msg {
public:
  template <typename T> Msg &operator<<(const T &v) {
    d_oss << v;
    return *this;
  }
 
  Msg &operator<<(std::ostream &(*manip)(std::ostream &)) {
    d_oss << manip;
    return *this;
  }
 
  std::string str() const { return d_oss.str(); }
 
  operator std::string() const { return d_oss.str(); }
 
private:
  std::ostringstream d_oss;
};
 
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 <typename T, typename U> inline std::string printStr(const std::map<T, U> &map,
                                                 int nt = print_default_tab) {
 
    auto tabS = getTabS(nt);
    std::ostringstream oss;
    oss << tabS;
    for (const auto &l : map) {
      oss << "{" << l.first << " : " << l.second << "}";
      if (std::next(&l) != map.cend())
        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);
};
 
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);
 
bool logEnabled(int priority, bool check_condition = true,
                int override_priority = -1);
 
void log(int priority, const std::string &str, bool check_condition = true,
         int override_priority = -1, bool screen_out = false);
 
void log(int priority, std::ostringstream &oss, bool check_condition = true,
         int override_priority = -1, bool screen_out = false);
 
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) {
      throw std::runtime_error(
          util::io::Msg()
          << "checkAndCreateNewFilename(): Argument filename = "
          << filename << " has extension = "
          << f_ext << " which does not match expected extension = "
          << filename_ext << std::endl);
    }
  }
 
  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