factory.hpp

 
  template <typename DataType>
  static File CreateFile(const char* name, DataType& raw)
  {
    using StoredType = std::remove_reference_t<DataType>;
 
    File file(name);
    if constexpr (std::is_const_v<StoredType>)
    {
      file.file_type_ = FileType::READ_ONLY;
      file.addr_const_ = &raw;
    }
    else
    {
      file.file_type_ = FileType::READ_WRITE;
      file.addr_ = &raw;
    }
 
    file.size_ = sizeof(StoredType);
    return file;
  }
 
  template <typename ArgType>
  static File CreateFile(const char* name,
                         int (*exec)(ArgType arg, int argc, char** argv), ArgType&& arg)
  {
    using StoredArgType = std::remove_reference_t<ArgType>;
    struct ExecutableBlock
    {
      StoredArgType arg_;
      decltype(exec) exec_fun_;
    };
 
    File file(name);
 
    auto block = new ExecutableBlock{std::forward<ArgType>(arg), exec};
    file.file_type_ = FileType::EXEC;
    file.arg_ = block;
 
    file.exec_ = [](void* raw, int argc, char** argv)
    {
      auto* block = static_cast<ExecutableBlock*>(raw);
      return block->exec_fun_(block->arg_, argc, argv);
    };
 
    return file;
  }
 
  template <typename ArgType>
  static File CreateCommand(const char* name,
                            int (*exec)(ArgType arg, int argc, char** argv),
                            ArgType&& arg)
  {
    return CreateFile(name, exec, std::forward<ArgType>(arg));
  }
 
  static Dir CreateDir(const char* name) { return Dir(name); }
 
  void Add(File& file) { root_.Add(file); }
 
  void Add(Dir& dir) { root_.Add(dir); }
 
  void Add(Custom& custom) { root_.Add(custom); }
 
  File* FindFile(const char* name) { return root_.FindFileRev(name); }
 
  Dir* FindDir(const char* name) { return root_.FindDirRev(name); }
 
  Custom* FindCustom(const char* name) { return root_.FindCustomRev(name); }
 
  Dir root_;  
  Dir bin_;