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