io.h

#ifndef SOURCEMETA_CORE_IO_H_
#define SOURCEMETA_CORE_IO_H_
 
#ifndef SOURCEMETA_CORE_IO_EXPORT
#include <sourcemeta/core/io_export.h>
#endif
 
// NOLINTBEGIN(misc-include-cleaner)
#include <sourcemeta/core/io_atomic.h>
#include <sourcemeta/core/io_binary.h>
#include <sourcemeta/core/io_bytestream.h>
#include <sourcemeta/core/io_error.h>
#include <sourcemeta/core/io_fileview.h>
#include <sourcemeta/core/io_temporary.h>
// NOLINTEND(misc-include-cleaner)
 
#include <cstddef>    // std::byte
#include <filesystem> // std::filesystem
#include <fstream>    // std::basic_ifstream
#include <functional> // std::function
#include <ios>      // std::ios, std::streamoff, std::streampos, std::streamsize
#include <iostream> // std::cin
#include <istream>  // std::basic_istream
#include <limits>   // std::numeric_limits
#include <ostream>  // std::ostream
#include <span>     // std::span
#include <sstream>  // std::basic_ostringstream
#include <string>   // std::basic_string, std::char_traits, std::string
#include <string_view>  // std::string_view
#include <system_error> // std::error_code

 
namespace sourcemeta::core {

SOURCEMETA_CORE_IO_EXPORT
auto canonical(const std::filesystem::path &path) -> std::filesystem::path;

SOURCEMETA_CORE_IO_EXPORT
auto weakly_canonical(const std::filesystem::path &path)
    -> std::filesystem::path;

SOURCEMETA_CORE_IO_EXPORT
auto is_under_path(const std::filesystem::path &path,
                   const std::filesystem::path &prefix) -> bool;

SOURCEMETA_CORE_IO_EXPORT
auto is_lexically_under_path(const std::filesystem::path &path,
                             const std::filesystem::path &prefix) -> bool;

SOURCEMETA_CORE_IO_EXPORT
auto strip_path_prefix(const std::filesystem::path &path,
                       const std::filesystem::path &prefix)
    -> std::filesystem::path;

template <typename CharT = char, typename Traits = std::char_traits<CharT>>
auto read_file(const std::filesystem::path &path)
    -> std::basic_ifstream<CharT, Traits> {
  if (std::filesystem::is_directory(path)) {
    throw IOIsADirectoryError{path};
  }
 
  const auto canonical_path{sourcemeta::core::canonical(path)};
  // Text mode translates line endings on some platforms, which desynchronises
  // character offsets from byte offsets and makes the stream impossible to
  // reposition by arithmetic
  std::basic_ifstream<CharT, Traits> stream{canonical_path, std::ios::binary};
  if (!stream.is_open()) {
    throw IOFilePermissionError{canonical_path};
  }
 
  stream.exceptions(std::basic_ifstream<CharT, Traits>::badbit);
  return stream;
}

template <typename CharT = char, typename Traits = std::char_traits<CharT>>
auto read_to_string(std::basic_istream<CharT, Traits> &stream)
    -> std::basic_string<CharT, Traits> {
  const auto start{stream.tellg()};
  if (start != static_cast<std::streampos>(-1)) {
    stream.seekg(0, std::ios::end);
    const auto end{stream.tellg()};
    stream.seekg(start);
    if (end > start) {
      std::basic_string<CharT, Traits> result;
      result.resize(static_cast<std::size_t>(end - start));
      stream.read(result.data(), static_cast<std::streamsize>(result.size()));
      // Text-mode reads may return fewer characters than the byte count
      // (i.e. CRLF collapses to LF on Windows), so trim to actual.
      result.resize(static_cast<std::size_t>(stream.gcount()));
      return result;
    }
  }
 
  std::basic_ostringstream<CharT, Traits> buffer;
  buffer << stream.rdbuf();
  return buffer.str();
}

template <typename CharT = char, typename Traits = std::char_traits<CharT>>
auto resume_stream(std::basic_istream<CharT, Traits> &stream,
                   const std::streampos start, const std::streamsize count)
    -> void {
  if (start == static_cast<std::streampos>(-1)) {
    return;
  }
 
  stream.clear();
  stream.seekg(start + static_cast<std::streamoff>(count));
}

template <typename CharT = char, typename Traits = std::char_traits<CharT>>
auto read_file_to_string(const std::filesystem::path &path)
    -> std::basic_string<CharT, Traits> {
  if (std::filesystem::is_directory(path)) {
    throw IOIsADirectoryError{path};
  }
 
  const auto canonical_path{sourcemeta::core::canonical(path)};
  // Binary, so that the result is the bytes the file holds. Text mode collapses
  // CRLF to LF on some platforms, which silently makes the contents, its size
  // and every offset into it disagree with the file itself
  std::basic_ifstream<CharT, Traits> stream{canonical_path, std::ios::binary};
  if (!stream.is_open()) {
    throw IOFilePermissionError{canonical_path};
  }
 
  stream.exceptions(std::basic_ifstream<CharT, Traits>::badbit);
 
  // `file_size` only works on regular files, so when it cannot determine a
  // size (FIFOs from process substitution, sockets, pipes, or any other
  // stat failure) fall back to a streaming read on the already-open stream.
  std::error_code file_size_error;
  const auto size{std::filesystem::file_size(canonical_path, file_size_error)};
  if (file_size_error) {
    return read_to_string<CharT, Traits>(stream);
  }
 
  // On 32-bit targets the file size can exceed what an in-memory string can
  // hold, in which case fall back to a streaming read that grows as needed
  if constexpr (std::numeric_limits<decltype(size)>::max() >
                std::numeric_limits<std::size_t>::max()) {
    if (size > std::numeric_limits<std::size_t>::max()) {
      return read_to_string<CharT, Traits>(stream);
    }
  }
 
  std::basic_string<CharT, Traits> result;
  result.resize(static_cast<std::size_t>(size));
  stream.read(result.data(), static_cast<std::streamsize>(result.size()));
  // The size was taken before the read, so a file that shrank in between hands
  // back fewer bytes than were asked for
  result.resize(static_cast<std::size_t>(stream.gcount()));
  return result;
}

inline auto read_stdin() -> std::string { return read_to_string(std::cin); }

template <typename Callback>
auto for_each_line(std::istream &stream, Callback callback) -> void {
  std::string line;
  while (std::getline(stream, line)) {
    std::string_view view{line};
    if (!view.empty() && view.back() == '\r') {
      view.remove_suffix(1);
    }
 
    callback(view);
  }
}

SOURCEMETA_CORE_IO_EXPORT
auto hardlink_directory(const std::filesystem::path &source,
                        const std::filesystem::path &destination) -> void;

SOURCEMETA_CORE_IO_EXPORT
auto write_file(const std::filesystem::path &path,
                const std::string_view contents) -> void;

SOURCEMETA_CORE_IO_EXPORT
auto write_file(const std::filesystem::path &path,
                const std::span<const std::byte> contents) -> void;

SOURCEMETA_CORE_IO_EXPORT
auto write_file(const std::filesystem::path &path,
                const std::function<void(std::ostream &)> &writer) -> void;

SOURCEMETA_CORE_IO_EXPORT
auto flush(const std::filesystem::path &path) -> void;
 
} // namespace sourcemeta::core
 
#endif