[Redesign] Generator (#137)

Author: coder137

buildcc/lib/command/include/command/command.h

@@ -28,6 +28,7 @@ class Command {
 public:
   explicit Command() = default;
 
+  void AddDefaultArgument(const char *key, const std::string &value);
   void AddDefaultArguments(
       const std::unordered_map<const char *, std::string> &arguments);
 

buildcc/lib/command/src/command.cpp

@@ -26,6 +26,10 @@
 
 namespace buildcc {
 
+void Command::AddDefaultArgument(const char *key, const std::string &value) {
+  default_values_.emplace(key, value);
+}
+
 void Command::AddDefaultArguments(
     const std::unordered_map<const char *, std::string> &arguments) {
   default_values_.insert(arguments.begin(), arguments.end());

buildcc/lib/target/include/target/generator.h

@@ -19,95 +19,64 @@
 
 #include <functional>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "taskflow/taskflow.hpp"
 
 #include "env/env.h"
 
+#include "command/command.h"
+
 #include "target/builder_interface.h"
 
 #include "target/generator_loader.h"
 #include "target/path.h"
 
 namespace buildcc::base {
 
-typedef std::function<bool(
-    const internal::geninfo_unordered_map &previous_info,
-    const internal::geninfo_unordered_map &current_info,
-    std::vector<const internal::GenInfo *> &output_generated_files,
-    std::vector<const internal::GenInfo *> &output_dummy_generated_files)>
-    custom_regenerate_cb_params;
-
 class Generator : public BuilderInterface {
 public:
-  Generator(const std::string &name, const fs::path &path)
-      : name_(name), loader_(name, path) {
-    unique_id_ = name;
+  Generator(const std::string &name,
+            const fs::path &target_path_relative_to_root, bool parallel = false)
+      : name_(name), generator_root_dir_(env::get_project_root_dir() /
+                                         target_path_relative_to_root),
+        generator_build_dir_(env::get_project_build_dir() / name),
+        loader_(name, generator_build_dir_), parallel_(parallel) {
+    Initialize();
   }
   Generator(const Generator &generator) = delete;
 
   /**
-   * @brief Define your input - output - command relation
+   * @brief Add default arguments for input, output and command requirements
    *
-   * @param name GenInfo task name
-   * @param inputs Input files
-   * @param outputs Output files generated
-   * @param commands Commands for input files to generate output files
-   * @param parallel Run commands in parallel
-   */
-  void AddGenInfo(const std::string &name,
-                  const internal::fs_unordered_set &inputs,
-                  const internal::fs_unordered_set &outputs,
-                  const std::vector<std::string> &commands, bool parallel);
-
-  /**
-   * @brief Implement your own Regenerate callback.
-   * - See `Regenerate` function for generic implementation
-   * - See `Recheck*` APIs in BuilderInterface for custom checks
-   *
-   * @param cb Gives 4 parameters
-   *
-   * const internal::geninfo_unordered_map &previous_info
-   * const internal::geninfo_unordered_map &current_info
-   * std::vector<const internal::GenInfo *> &output_generated_files
-   * std::vector<const internal::GenInfo *> &output_dummy_generated_files
-   *
-   * @return cb should return true or false which sets the dirty_ flag
-   */
-  void AddCustomRegenerateCb(const custom_regenerate_cb_params &cb);
-
-  /**
-   * @brief Custom pre generate callback run before the core generate function
+   * @param arguments Key-Value pair for arguments
+   * NOTE, Key must be a variable (lvalue) not a constant (rvalue)
    *
-   * @param cb
    */
-  void AddPregenerateCb(const std::function<void(void)> &cb);
+  void AddDefaultArguments(
+      const std::unordered_map<const char *, std::string> &arguments);
 
-  /**
-   * @brief Custom post generate callback run after the core generate function
-   * IF dirty_ == true
-   *
-   * @param cb
-   */
-  void AddPostgenerateCb(const std::function<void(void)> &cb);
+  void AddInput(const std::string &absolute_input_pattern,
+                const char *identifier = nullptr);
+  void AddOutput(const std::string &absolute_output_pattern,
+                 const char *identifier = nullptr);
+  void AddCommand(
+      const std::string &command_pattern,
+      const std::unordered_map<const char *, std::string> &arguments = {});
 
   void Build() override;
-  void Build(tf::FlowBuilder &builder);
 
   // Getter
   fs::path GetBinaryPath() const { return loader_.GetBinaryPath(); }
   tf::Taskflow &GetTaskflow() { return tf_; }
 
 private:
-  void GenerateTask(tf::FlowBuilder &builder);
+  void Initialize();
+
+  void GenerateTask();
   void Convert();
-  void
-  BuildGenerate(std::vector<const internal::GenInfo *> &generated_files,
-                std::vector<const internal::GenInfo *> &dummy_generated_files);
-  bool
-  Regenerate(std::vector<const internal::GenInfo *> &generated_files,
-             std::vector<const internal::GenInfo *> &dummy_generated_files);
+  void BuildGenerate();
 
   bool Store() override;
 
@@ -120,15 +89,20 @@ class Generator : public BuilderInterface {
   void CommandChanged();
 
 private:
+  // Constructor
   std::string name_;
-  std::unordered_map<std::string, internal::GenInfo> current_info_;
-
-  custom_regenerate_cb_params custom_regenerate_cb_;
-  std::function<void(void)> pregenerate_cb_{[]() {}};
-  std::function<void(void)> postgenerate_cb_{[]() {}};
-
+  fs::path generator_root_dir_;
+  fs::path generator_build_dir_;
   internal::GeneratorLoader loader_;
 
+  // Serialization
+  internal::default_files current_input_files_;
+  internal::fs_unordered_set current_output_files_;
+  std::vector<std::string> current_commands_;
+  bool parallel_{false};
+
+  // Internal
+  Command command_;
   tf::Taskflow tf_;
 };
 

buildcc/lib/target/include/target/generator_loader.h

@@ -29,45 +29,10 @@
 
 namespace buildcc::internal {
 
-struct GenInfo {
-  std::string name;
-  default_files inputs;
-  fs_unordered_set outputs;
-  std::vector<std::string> commands;
-  bool parallel{false};
-
-  static GenInfo CreateInternalGenInfo(const std::string &n,
-                                       const path_unordered_set &internal_i,
-                                       const fs_unordered_set &o,
-                                       const std::vector<std::string> &c,
-                                       bool p) {
-    return GenInfo(n, internal_i, {}, o, c, p);
-  }
-
-  static GenInfo CreateUserGenInfo(const std::string &n,
-                                   const fs_unordered_set &user_i,
-                                   const fs_unordered_set &o,
-                                   const std::vector<std::string> &c, bool p) {
-    return GenInfo(n, {}, user_i, o, c, p);
-  }
-
-  GenInfo(GenInfo &&info) = default;
-  GenInfo(const GenInfo &info) = delete;
-
-private:
-  explicit GenInfo(const std::string &n, const path_unordered_set &internal_i,
-                   const fs_unordered_set &user_i, const fs_unordered_set &o,
-                   const std::vector<std::string> &c, bool p)
-      : name(n), inputs(internal_i, user_i), outputs(o), commands(c),
-        parallel(p) {}
-};
-
-typedef std::unordered_map<std::string, GenInfo> geninfo_unordered_map;
-
 class GeneratorLoader : public LoaderInterface {
 public:
-  GeneratorLoader(const std::string &name, const fs::path &path)
-      : name_(name), path_(path) {}
+  GeneratorLoader(const std::string &name, const fs::path &absolute_path)
+      : name_(name), path_(absolute_path) {}
 
   GeneratorLoader(const GeneratorLoader &loader) = delete;
 
@@ -78,13 +43,25 @@ class GeneratorLoader : public LoaderInterface {
     return path_ / fmt::format("{}.bin", name_);
   }
 
-  const geninfo_unordered_map &GetLoadedInfo() { return loaded_info_; }
+  const internal::path_unordered_set &GetLoadedInputFiles() const {
+    return loaded_input_files_;
+  }
+
+  const internal::fs_unordered_set &GetLoadedOutputFiles() const {
+    return loaded_output_files_;
+  }
+
+  const std::vector<std::string> &GetLoadedCommands() const {
+    return loaded_commands_;
+  }
 
 private:
   std::string name_;
   fs::path path_;
 
-  geninfo_unordered_map loaded_info_;
+  internal::path_unordered_set loaded_input_files_;
+  internal::fs_unordered_set loaded_output_files_;
+  std::vector<std::string> loaded_commands_;
 };
 
 } // namespace buildcc::internal

buildcc/lib/target/include/target/path.h

@@ -132,9 +132,6 @@ typedef std::unordered_set<fs::path, PathHash> fs_unordered_set;
 // optimization by caching the `user` information and `internal` information
 // together
 struct default_files {
-  path_unordered_set internal;
-  fs_unordered_set user;
-
   default_files() {}
   default_files(const path_unordered_set &i, const fs_unordered_set &u)
       : internal(i), user(u) {}
@@ -150,6 +147,10 @@ struct default_files {
     }
   }
 
+public:
+  path_unordered_set internal;
+  fs_unordered_set user;
+
 private:
   bool done_once{false};
 };

buildcc/lib/target/include/target/target.h

@@ -131,8 +131,8 @@ class Target : public BuilderInterface {
       : name_(name), type_(type), toolchain_(toolchain), config_(config),
         target_root_dir_(env::get_project_root_dir() /
                          target_path_relative_to_root),
-        target_build_dir_(fs::path(env::get_project_build_dir()) /
-                          toolchain.GetName() / name),
+        target_build_dir_(env::get_project_build_dir() / toolchain.GetName() /
+                          name),
         loader_(name, target_build_dir_), ext_(*this), compile_pch_(*this),
         compile_object_(*this), link_target_(*this) {
     Initialize();

buildcc/lib/target/mock/generator/task.cpp

@@ -6,32 +6,30 @@
 
 namespace buildcc::base {
 
-void Generator::GenerateTask(tf::FlowBuilder &builder) {
-  (void)builder;
-
-  pregenerate_cb_();
+void Generator::GenerateTask() {
   Convert();
-  std::vector<const internal::GenInfo *> generated_files;
-  std::vector<const internal::GenInfo *> dummy_generated_files;
-  BuildGenerate(generated_files, dummy_generated_files);
+  BuildGenerate();
+
+  if (!dirty_) {
+    return;
+  }
 
   // NOTE, info->parallel is not checked
-  for (const auto &info : generated_files) {
-    for (const auto &command : info->commands) {
-      bool success = Command::Execute(command);
-      env::assert_fatal(success, fmt::format("{} failed", command));
-    }
-    for (const auto &output_file : info->outputs) {
-      std::string file = output_file.string();
-      bool success = env::SaveFile(file.c_str(), "", false);
-      env::assert_fatal(success, fmt::format("{} failed", file));
-    }
+  // Run the command
+  for (const auto &command : current_commands_) {
+    bool success = Command::Execute(command);
+    env::assert_fatal(success, fmt::format("{} failed", command));
+  }
+
+  // Generate the output file
+  for (const auto &output_file : current_output_files_) {
+    std::string file = output_file.string();
+    bool success = env::SaveFile(file.c_str(), "", false);
+    env::assert_fatal(success, fmt::format("{} failed", file));
   }
-  (void)dummy_generated_files;
 
   if (dirty_) {
     Store();
-    postgenerate_cb_();
   }
 }