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_;