files.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the Apache 2.0 License.
#pragma once
 
#include <cstring>
#include <fstream>
#include <glob.h>
#include <iostream>
#include <nlohmann/json.hpp>
#include <optional>
#include <sstream>
#include <string>
#include <vector>
 
#define FMT_HEADER_ONLY
#include <fmt/format.h>
#include <fmt/ostream.h>
 
namespace files
{
  namespace fs = std::filesystem;
 
  static bool exists(const std::string& file)
  {
    std::ifstream f(file.c_str());
    return f.good();
  }
 
  static std::vector<uint8_t> slurp(
    const std::string& file, bool optional = false)
  {
    std::ifstream f(file, std::ios::binary | std::ios::ate);
 
    if (!f)
    {
      if (optional)
      {
        return {};
      }
      std::cerr << "Could not open file " << file << std::endl;
      exit(-1); // NOLINT(concurrency-mt-unsafe)
    }
 
    auto size = f.tellg();
    f.seekg(0, std::ios::beg);
 
    std::vector<uint8_t> data(size);
    f.read(reinterpret_cast<char*>(data.data()), size);
 
    if (!optional && !f)
    {
      std::cerr << "Could not read file " << file << std::endl;
      exit(-1); // NOLINT(concurrency-mt-unsafe)
    }
    return data;
  }
 
  static std::string slurp_string(
    const std::string& file, bool optional = false)
  {
    auto v = slurp(file, optional);
    return {v.begin(), v.end()};
  }
 
  static std::optional<std::string> try_slurp_string(const std::string& file)
  {
    if (!fs::exists(file))
    {
      return std::nullopt;
    }
    return files::slurp_string(file);
  }
 
  static nlohmann::json slurp_json(
    const std::string& file, bool optional = false)
  {
    auto v = slurp(file, optional);
    if (v.empty())
    {
      return {};
    }
 
    return nlohmann::json::parse(v.begin(), v.end());
  }
 
  static void dump(const std::vector<uint8_t>& data, const std::string& file)
  {
    using namespace std;
    ofstream f(file, ios::binary | ios::trunc);
    f.write(reinterpret_cast<const char*>(data.data()), data.size());
    if (!f)
    {
      throw logic_error("Failed to write to file: " + file);
    }
  }
 
  static void dump(const std::string& data, const std::string& file)
  {
    dump(std::vector<uint8_t>(data.begin(), data.end()), file);
  }
 
  static void rename(const fs::path& src, const fs::path& dst)
  {
    std::error_code ec;
    fs::rename(src, dst, ec);
    if (ec)
    {
      throw std::logic_error(fmt::format(
        "Could not rename file {} to {}: {}",
        src.string(),
        dst.string(),
        ec.message()));
    }
  }
 
  static void create_directory(const fs::path& dir)
  {
    std::error_code ec;
    fs::create_directory(dir, ec);
    if (ec && ec != std::errc::file_exists)
    {
      throw std::logic_error(fmt::format(
        "Could not create directory {}: {}", dir.string(), ec.message()));
    }
  }
}