command_handler.h

Go to the documentation of this file.

#ifndef YAZE_SRC_CLI_SERVICE_RESOURCES_COMMAND_HANDLER_H_
#define YAZE_SRC_CLI_SERVICE_RESOURCES_COMMAND_HANDLER_H_
 
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "rom/rom.h"
#include "cli/service/resources/command_context.h"
#include "core/asar_wrapper.h" // For AsarWrapper
#include "core/project.h"      // For YazeProject
 
namespace yaze {
namespace cli {
namespace resources {
 
class CommandHandler {
 public:
  virtual ~CommandHandler() = default;
 
  struct DescriptorEntry {
    std::string name;
    std::string description;
    std::string todo_reference;
  };
 
  struct Descriptor {
    std::string display_name;
    std::string summary;
    std::string todo_reference;
    std::vector<DescriptorEntry> entries;
  };
 
  absl::Status Run(const std::vector<std::string>& args, Rom* rom_context,
                   std::string* captured_output = nullptr);
 
  virtual std::string GetName() const = 0;
 
  virtual Descriptor Describe() const;
 
  virtual std::string GetUsage() const = 0;
 
  virtual bool RequiresRom() const { return true; }
 
  virtual bool RequiresLabels() const { return false; }
  
  virtual void SetProjectContext(project::YazeProject* project) { project_ = project; }
  
  virtual void SetAsarWrapper(core::AsarWrapper* asar_wrapper) { asar_wrapper_ = asar_wrapper; }
 
  virtual void SetRomContext(Rom* rom) { rom_ = rom; }
 
  virtual void SetSymbolProvider(emu::debug::SymbolProvider* provider) {
    symbol_provider_ = provider;
  }
 
 protected:
  virtual absl::Status ValidateArgs(const ArgumentParser& parser) = 0;
 
  virtual absl::Status Execute(Rom* rom, const ArgumentParser& parser,
                               OutputFormatter& formatter) = 0;
 
  virtual std::string GetDefaultFormat() const { return "json"; }
 
  virtual std::string GetOutputTitle() const { return "Result"; }
 
  Rom* rom_ = nullptr;
  emu::debug::SymbolProvider* symbol_provider_ = nullptr;
  project::YazeProject* project_ = nullptr;
  core::AsarWrapper* asar_wrapper_ = nullptr;
};
 
#define DEFINE_COMMAND_HANDLER(name, usage_str, validate_body, execute_body)        \
  class name##CommandHandler : public CommandHandler {                              \
   public:                                                                         \
    std::string GetName() const override { return #name; }                         \
    std::string GetUsage() const override { return usage_str; }                    \
   protected:                                                                      \
    absl::Status ValidateArgs(const ArgumentParser& parser) override               \
    validate_body                                                                  \
    absl::Status Execute(Rom* rom, const ArgumentParser& parser,                   \
                         OutputFormatter& formatter) override                     \
    execute_body                                                                   \
  };
 
}  // namespace resources
}  // namespace cli
}  // namespace yaze
 
#endif  // YAZE_SRC_CLI_SERVICE_RESOURCES_COMMAND_HANDLER_H_