ramfs.hpp

#pragma once
 
#include <functional>
 
#include "libxr_assert.hpp"
#include "libxr_def.hpp"
#include "libxr_rw.hpp"
#include "libxr_type.hpp"
#include "rbt.hpp"
 
namespace LibXR
{
class RamFS
{
 public:
  RamFS(const char *name = "ramfs");
 
  static int CompareStr(const char *const &a, const char *const &b);
 
  enum class FsNodeType : uint8_t
  {
    FILE,     
    DIR,      
    DEVICE,   
    STORAGE,  
    UNKNOW,   
  };
 
  enum class FileType : uint8_t
  {
    READ_ONLY,   
    READ_WRITE,  
    EXEC,        
  };
 
  class Dir;
 
  class FsNode
  {
   public:
    const char *name;
    FsNodeType type;
    Dir *parent;
  };
 
  typedef class FileNode : public FsNode
  {
   public:
    union
    {
      void *addr;              
      const void *addr_const;  
      int (*exec)(void *raw, int argc,
                  char **argv);  
    };
 
    union
    {
      size_t size;  
      void *arg;    
    };
 
    FileType type;  
 
    int Run(int argc, char **argv);
 
    template <typename DataType, SizeLimitMode LimitMode = SizeLimitMode::MORE>
    const DataType &GetData()
    {
      LibXR::Assert::SizeLimitCheck<LimitMode>(sizeof(DataType), size);
      if (type == FileType::READ_WRITE)
      {
        return *reinterpret_cast<DataType *>(addr);
      }
      else if (type == FileType::READ_ONLY)
      {
        return *reinterpret_cast<const DataType *>(addr_const);
      }
      else
      {
        ASSERT(false);
        const void *addr = nullptr;
        return *reinterpret_cast<const DataType *>(addr);
      }
    }
  } FileNode;
 
  typedef RBTree<const char *>::Node<FileNode> File;
 
  struct DeviceNode : public FsNode
  {
    ReadPort read_port;    
    WritePort write_port;  
  };
 
  class Device : public RBTree<const char *>::Node<DeviceNode>
  {
   public:
    Device(const char *name, const ReadPort &read_port = ReadPort(),
           const WritePort &write_port = WritePort());
 
    template <typename ReadOperation>
    ErrorCode Read(ReadOperation &&op, RawData data)
    {
      return data_.read_port(data, std::forward<ReadOperation>(op));
    }
 
    template <typename WriteOperation>
    ErrorCode Write(WriteOperation &&op, ConstRawData data)
    {
      return data_.write_port(data, std::forward<WriteOperation>(op));
    }
 
    uint32_t device_type;  
  };
 
  typedef struct
  {
    // TODO:
    uint32_t res;
  } StorageBlock;
 
  class DirNode : public FsNode
  {
   public:
    DirNode() : rbt(RBTree<const char *>(CompareStr)) {}
 
    RBTree<const char *> rbt;  
  };
 
  class Dir : public RBTree<const char *>::Node<DirNode>
  {
   public:
    void Add(File &file)
    {
      (*this)->rbt.Insert(file, file->name);
      file->parent = this;
    }
    void Add(Dir &dir)
    {
      (*this)->rbt.Insert(dir, dir->name);
      dir->parent = this;
    }
    void Add(Device &dev)
    {
      (*this)->rbt.Insert(dev, dev->name);
      dev->parent = this;
    }
 
    File *FindFile(const char *name);
 
    File *FindFileRev(const char *name);
 
    Dir *FindDir(const char *name);
 
    Dir *FindDirRev(const char *name);
 
    Device *FindDeviceRev(const char *name);
 
    Device *FindDevice(const char *name);
  };
 
  template <typename DataType>
  static File CreateFile(const char *name, DataType &raw)
  {
    File file;
    char *name_buff = new char[strlen(name) + 1];
    strcpy(name_buff, name);
    file->name = name_buff;
 
    if (std::is_const<DataType>())
    {
      file->type = FileType::READ_ONLY;
      file->addr_const = &raw;
    }
    else
    {
      file->type = FileType::READ_WRITE;
      file->addr = &raw;
    }
 
    file->size = sizeof(DataType);
 
    return file;
  }
 
  template <typename ArgType>
  static File CreateFile(const char *name,
                         int (*exec)(ArgType arg, int argc, char **argv), ArgType &&arg)
  {
    typedef struct
    {
      ArgType arg;
      decltype(exec) exec_fun;
    } FileBlock;
 
    File file;
 
    char *name_buff = new char[strlen(name) + 1];
    strcpy(name_buff, name);
    file->name = name_buff;
    file->type = FileType::EXEC;
 
    auto block = new FileBlock;
    block->arg = std::forward<ArgType>(arg);
    block->exec_fun = exec;
    file->arg = block;
 
    auto fun = [](void *arg, int argc, char **argv)
    {
      auto block = reinterpret_cast<FileBlock *>(arg);
      return block->exec_fun(block->arg, argc, argv);
    };
 
    file->exec = fun;
 
    return file;
  }
 
  static Dir CreateDir(const char *name)
  {
    Dir dir;
 
    char *name_buff = new char[strlen(name) + 1];
    strcpy(name_buff, name);
    dir->name = name_buff;
    dir->type = FsNodeType::DIR;
 
    return dir;
  }
 
  void Add(File &file) { root_.Add(file); }
  void Add(Dir &dir) { root_.Add(dir); }
  void Add(Device &dev) { root_.Add(dev); }
 
  File *FindFile(const char *name) { return root_.FindFileRev(name); }
  Dir *FindDir(const char *name) { return root_.FindDirRev(name); }
  Device *FindDevice(const char *name) { return root_.FindDeviceRev(name); }
 
  Dir root_;
 
  Dir bin_;
 
  Dir dev_;
};
}  // namespace LibXR