file.hpp

 
class File : public FsNode
{
 public:
  [[nodiscard]] bool IsReadOnly() const { return file_type_ == FileType::READ_ONLY; }
 
  [[nodiscard]] bool IsReadWrite() const { return file_type_ == FileType::READ_WRITE; }
 
  [[nodiscard]] bool IsExecutable() const { return file_type_ == FileType::EXEC; }
 
  int Run(int argc, char** argv);
 
  template <typename DataType, SizeLimitMode LimitMode = SizeLimitMode::MORE>
  decltype(auto) Data()
  {
    using RequestedType = std::remove_reference_t<DataType>;
    using StoredType = std::remove_cv_t<RequestedType>;
    static_assert(!std::is_reference_v<DataType>);
    static_assert(!std::is_volatile_v<RequestedType>);
 
    ASSERT(LibXR::SizeLimitCheck(LimitMode, sizeof(StoredType), size_));
    if constexpr (std::is_const_v<RequestedType>)
    {
      return *ReadableDataPtr<StoredType>();
    }
    else
    {
      return *WritableDataPtr<StoredType>();
    }
  }
 
  template <typename DataType, SizeLimitMode LimitMode = SizeLimitMode::MORE>
  decltype(auto) Data() const
  {
    using RequestedType = std::remove_reference_t<DataType>;
    using StoredType = std::remove_cv_t<RequestedType>;
    static_assert(!std::is_reference_v<DataType>);
    static_assert(!std::is_volatile_v<RequestedType>);
 
    ASSERT(LibXR::SizeLimitCheck(LimitMode, sizeof(StoredType), size_));
    return *ReadableDataPtr<StoredType>();
  }
 
  [[nodiscard]] RawData Data() { return RawData(WritableDataPtr<void>(), size_); }
 
  [[nodiscard]] ConstRawData Data() const
  {
    return ConstRawData(ReadableDataPtr<void>(), size_);
  }
 
 private:
  using ExecFun = int (*)(void* raw, int argc, char** argv);
 
  [[noreturn]] static void DataAccessPanic()
  {
    REQUIRE(false);
    std::abort();
  }
 
  template <typename DataType>
  const DataType* ReadableDataPtr() const
  {
    if (file_type_ == FileType::READ_WRITE)
    {
      return static_cast<const DataType*>(addr_);
    }
    if (file_type_ == FileType::READ_ONLY)
    {
      return static_cast<const DataType*>(addr_const_);
    }
    DataAccessPanic();
  }
 
  template <typename DataType>
  DataType* WritableDataPtr()
  {
    if (file_type_ != FileType::READ_WRITE)
    {
      DataAccessPanic();
    }
    return static_cast<DataType*>(addr_);
  }
 
  File();
 
  explicit File(const char* name);
 
  union
  {
    void* addr_;              
    const void* addr_const_;  
    ExecFun exec_;            
  };
 
  void* arg_ = nullptr;  
  size_t size_ = 0;      
  FileType file_type_ =
      FileType::READ_ONLY;  
 
  friend class RamFS;
};