enhance: Add Result::write_data method

diff --git a/src/Result.cpp b/src/Result.cpp
index 24a0dbe8e645e1985c906dc0cf90efc854926f78..f03e6d152c003efd82fadb0238bd8cddc10d2f45 100644 (file)
--- a/src/Result.cpp
+++ b/src/Result.cpp
@@ -308,9 +308,15 @@ Writer::Writer(Context& ctx, const std::string& result_path)
 }
 
 void
-Writer::write(FileType file_type, const std::string& file_path)
+Writer::write_data(const FileType file_type, const std::string& data)
 {
-  m_entries_to_write.emplace_back(file_type, file_path);
+  m_entries_to_write.push_back(Entry{file_type, ValueType::data, data});
+}
+
+void
+Writer::write_file(const FileType file_type, const std::string& path)
+{
+  m_entries_to_write.push_back(Entry{file_type, ValueType::path, path});
 }
 
 nonstd::expected<FileSizeAndCountDiff, std::string>
@@ -330,14 +336,14 @@ Writer::do_finalize()
   uint64_t payload_size = 0;
   payload_size += 1; // format_ver
   payload_size += 1; // n_entries
-  for (const auto& pair : m_entries_to_write) {
-    const auto& path = pair.second;
-    auto st = Stat::stat(path, Stat::OnError::throw_error);
-
-    payload_size += 1;         // embedded_file_marker
-    payload_size += 1;         // embedded_file_type
-    payload_size += 8;         // data_len
-    payload_size += st.size(); // data
+  for (const auto& entry : m_entries_to_write) {
+    payload_size += 1; // embedded_file_marker
+    payload_size += 1; // embedded_file_type
+    payload_size += 8; // data_len
+    payload_size +=    // data
+      entry.value_type == ValueType::data
+        ? entry.value.size()
+        : Stat::stat(entry.value, Stat::OnError::throw_error).size();
   }
 
   AtomicFile atomic_result_file(m_result_path, AtomicFile::Mode::binary);
@@ -356,30 +362,35 @@ Writer::do_finalize()
   writer.write_int<uint8_t>(m_entries_to_write.size());
 
   uint32_t entry_number = 0;
-  for (const auto& pair : m_entries_to_write) {
-    const auto file_type = pair.first;
-    const auto& path = pair.second;
-    LOG("Storing result file {}", path);
-
-    const bool store_raw = should_store_raw_file(m_ctx.config, file_type);
-    uint64_t file_size = Stat::stat(path, Stat::OnError::throw_error).size();
-
-    LOG("Storing {} file #{} {} ({} bytes) from {}",
+  for (const auto& entry : m_entries_to_write) {
+    const bool store_raw =
+      entry.value_type == ValueType::path
+      && should_store_raw_file(m_ctx.config, entry.file_type);
+    const uint64_t entry_size =
+      entry.value_type == ValueType::data
+        ? entry.value.size()
+        : Stat::stat(entry.value, Stat::OnError::throw_error).size();
+
+    LOG("Storing {} entry #{} {} ({} bytes){}",
         store_raw ? "raw" : "embedded",
         entry_number,
-        file_type_to_string(file_type),
-        file_size,
-        path);
+        file_type_to_string(entry.file_type),
+        entry_size,
+        entry.value_type == ValueType::data ? ""
+                                            : FMT(" from {}", entry.value));
 
     writer.write_int<uint8_t>(store_raw ? k_raw_file_marker
                                         : k_embedded_file_marker);
-    writer.write_int(UnderlyingFileTypeInt(file_type));
-    writer.write_int(file_size);
+    writer.write_int(UnderlyingFileTypeInt(entry.file_type));
+    writer.write_int(entry_size);
 
     if (store_raw) {
-      file_size_and_count_diff += write_raw_file_entry(path, entry_number);
+      file_size_and_count_diff +=
+        write_raw_file_entry(entry.value, entry_number);
+    } else if (entry.value_type == ValueType::data) {
+      writer.write(entry.value.data(), entry.value.size());
     } else {
-      write_embedded_file_entry(writer, path, file_size);
+      write_embedded_file_entry(writer, entry.value, entry_size);
     }
 
     ++entry_number;
@@ -394,7 +405,7 @@ Writer::do_finalize()
 void
 Result::Writer::write_embedded_file_entry(core::CacheEntryWriter& writer,
                                           const std::string& path,
-                                          uint64_t file_size)
+                                          const uint64_t file_size)
 {
   Fd file(open(path.c_str(), O_RDONLY | O_BINARY));
   if (!file) {

diff --git a/src/Result.hpp b/src/Result.hpp
index cca900f2f95ba03cd7d673f284b08fbdac0536c1..67aadd1c24798340a1c896e0e9abc83109625482 100644 (file)
--- a/src/Result.hpp
+++ b/src/Result.hpp
@@ -134,16 +134,28 @@ class Writer
 public:
   Writer(Context& ctx, const std::string& result_path);
 
-  // Register a file to include in the result. Does not throw.
-  void write(FileType file_type, const std::string& file_path);
+  // Register content to include in the result. Does not throw.
+  void write_data(FileType file_type, const std::string& data);
 
-  // Write registered files to the result. Returns an error message on error.
+  // Register a file path whose content should be included in the result. Does
+  // not throw.
+  void write_file(FileType file_type, const std::string& path);
+
+  // Write registered entries to the result. Returns an error message on error.
   nonstd::expected<FileSizeAndCountDiff, std::string> finalize();
 
 private:
+  enum class ValueType { data, path };
+  struct Entry
+  {
+    FileType file_type;
+    ValueType value_type;
+    std::string value;
+  };
+
   Context& m_ctx;
   const std::string m_result_path;
-  std::vector<std::pair<FileType, std::string>> m_entries_to_write;
+  std::vector<Entry> m_entries_to_write;
 
   FileSizeAndCountDiff do_finalize();
   static void write_embedded_file_entry(core::CacheEntryWriter& writer,

diff --git a/src/ccache.cpp b/src/ccache.cpp
index a01f2bd88a6945f5595e433660db415fafc90e91..980209fda436a20bf2ba3b546c505d4eb8042920 100644 (file)
--- a/src/ccache.cpp
+++ b/src/ccache.cpp
@@ -801,40 +801,44 @@ write_result(Context& ctx,
   }
 
   if (stderr_stat.size() > 0) {
-    result_writer.write(Result::FileType::stderr_output, stderr_path);
+    result_writer.write_file(Result::FileType::stderr_output, stderr_path);
   }
   // Write stdout only after stderr (better with MSVC), as ResultRetriever
   // will later print process them in the order they are read.
   if (stdout_stat.size() > 0) {
-    result_writer.write(Result::FileType::stdout_output, stdout_path);
+    result_writer.write_file(Result::FileType::stdout_output, stdout_path);
   }
   if (obj_stat) {
-    result_writer.write(Result::FileType::object, ctx.args_info.output_obj);
+    result_writer.write_file(Result::FileType::object,
+                             ctx.args_info.output_obj);
   }
   if (ctx.args_info.generating_dependencies) {
-    result_writer.write(Result::FileType::dependency, ctx.args_info.output_dep);
+    result_writer.write_file(Result::FileType::dependency,
+                             ctx.args_info.output_dep);
   }
   if (ctx.args_info.generating_coverage) {
     const auto coverage_file = find_coverage_file(ctx);
     if (!coverage_file.found) {
       return false;
     }
-    result_writer.write(coverage_file.mangled
-                          ? Result::FileType::coverage_mangled
-                          : Result::FileType::coverage_unmangled,
-                        coverage_file.path);
+    result_writer.write_file(coverage_file.mangled
+                               ? Result::FileType::coverage_mangled
+                               : Result::FileType::coverage_unmangled,
+                             coverage_file.path);
   }
   if (ctx.args_info.generating_stackusage) {
-    result_writer.write(Result::FileType::stackusage, ctx.args_info.output_su);
+    result_writer.write_file(Result::FileType::stackusage,
+                             ctx.args_info.output_su);
   }
   if (ctx.args_info.generating_diagnostics) {
-    result_writer.write(Result::FileType::diagnostic, ctx.args_info.output_dia);
+    result_writer.write_file(Result::FileType::diagnostic,
+                             ctx.args_info.output_dia);
   }
   if (ctx.args_info.seen_split_dwarf && Stat::stat(ctx.args_info.output_dwo)) {
     // Only store .dwo file if it was created by the compiler (GCC and Clang
     // behave differently e.g. for "-gsplit-dwarf -g1").
-    result_writer.write(Result::FileType::dwarf_object,
-                        ctx.args_info.output_dwo);
+    result_writer.write_file(Result::FileType::dwarf_object,
+                             ctx.args_info.output_dwo);
   }
 
   const auto file_size_and_count_diff = result_writer.finalize();