noodle_fs.h

Go to the documentation of this file.

 
#pragma once
 
// -----------------------------
// Path policy 
// -----------------------------
#if defined(NOODLE_USE_SDFAT)
  #define NOODLE_FS_NEEDS_LEADING_SLASH 0
#else
  #define NOODLE_FS_NEEDS_LEADING_SLASH 1
#endif
 
#ifndef NOODLE_MAX_FILENAME
  #define NOODLE_MAX_FILENAME 20   // plenty for "w28.txt" etc.
#endif
 
 
// ------------------------------
// 1) Enforce "exactly one"
// ------------------------------
#if (defined(NOODLE_USE_SDFAT) + defined(NOODLE_USE_SD_MMC) + defined(NOODLE_USE_FFAT) + defined(NOODLE_USE_LITTLEFS) + defined(NOODLE_USE_NONE)) != 1
# error "Select exactly ONE backend: NOODLE_USE_SDFAT, NOODLE_USE_SD_MMC, NOODLE_USE_FFAT, NOODLE_USE_LITTLEFS, or NOODLE_USE_NONE"
#endif
 
// ------------------------------
// 2) NONE backend
// ------------------------------
#if defined(NOODLE_USE_NONE)
 
  // Minimal "file-like" stub so code compiles.
  struct NDL_NullFile {
    bool _open = false;
 
    // Match common File/FsFile-ish methods used in embedded code.
    operator bool() const { return _open; }
    bool available() const { return false; }
    int  read() { return -1; }
    int  peek() { return -1; }
    size_t readBytes(char*, size_t) { return 0; }
    size_t write(uint8_t) { return 0; }
    size_t write(const uint8_t*, size_t) { return 0; }
    void flush() {}
    void close() { _open = false; }
    size_t size() const { return 0; }
    size_t position() const { return 0; }
    bool seek(uint32_t) { return false; }
    size_t println(byte v) { (void)v; return 0; }
    size_t println(float v) { (void)v; return 0; }
    size_t println(float v, int base) { (void)v; return 0; }
  };
 
  using NDL_File = NDL_NullFile;
 
  // No NOODLE_FS symbol in NONE mode.
 
#else
// ------------------------------
// 3) Real backends
// ------------------------------
  #if defined(NOODLE_USE_SDFAT)
    #include <SdFat.h>
 
#if defined(ESP32) || defined(ARDUINO_ARCH_ESP32) || \
    defined(ESP8266) || defined(ARDUINO_ARCH_ESP8266) || \
    defined(ARDUINO_ARCH_RP2040)
      using NDL_File = FsFile;   // SdFat on ESP32 typically uses FsFile
    #else
      using NDL_File = File;     // SdFat on AVR often uses File wrapper
    #endif
 
    extern SdFat NOODLE_FS;      // defined in noodle.cpp
 
  #elif defined(NOODLE_USE_FFAT)
    #include <FFat.h>
    #define NOODLE_FS FFat
    using NDL_File = File;
 
  #elif defined(NOODLE_USE_LITTLEFS)
    #include <LittleFS.h>
    #define NOODLE_FS LittleFS
    using NDL_File = File;
 
  #elif defined(NOODLE_USE_SD_MMC)
    #include <SD_MMC.h>
    #define NOODLE_FS SD_MMC
    using NDL_File = File;
 
  #endif
#endif
 
// ------------------------------
// 4) Unified API
// ------------------------------
// Safe string copy with NUL-termination
 
// Minimal bounded copy for short filenames
inline void noodle_copy_name(char* dst, size_t cap, const char* src) {
  if (!dst || cap == 0) return;
  if (!src) { dst[0] = '\0'; return; }
 
  size_t i = 0;
  while (src[i] != '\0' && (i + 1) < cap) {
    dst[i] = src[i];
    i++;
  }
  dst[i] = '\0';
}
 
// Normalize path according to backend policy
// Only safe for immediate use (open/remove); do not store returned pointer!
inline const char* noodle_norm_filename(const char* name) {
  if (!name) return "";
 
#if NOODLE_FS_NEEDS_LEADING_SLASH
  // One static buffer is enough for your simplified rules.
  // Size = '/' + filename + '\0'
  static char out[NOODLE_MAX_FILENAME + 2];
 
  out[0] = '/';
  noodle_copy_name(out + 1, NOODLE_MAX_FILENAME + 1, name);
  return out;
#else
  // SdFat: return as-is, no extra RAM used.
  return name;
#endif
}
 
// Open a file for reading
inline NDL_File noodle_fs_open_read(const char* path) {
  path = noodle_norm_filename(path);
#if defined(NOODLE_USE_NONE)
  (void)path;
  return NDL_File{}; // invalid handle
#elif defined(NOODLE_USE_SDFAT)
  return NOODLE_FS.open(path, O_RDONLY);
#else
  return NOODLE_FS.open(path, FILE_READ);
#endif
}
 
// Open a file for writing (creates or truncates)
inline NDL_File noodle_fs_open_write(const char* path) {
    path = noodle_norm_filename(path);
#if defined(NOODLE_USE_NONE)
  (void)path;
  return NDL_File{}; // invalid handle
#elif defined(NOODLE_USE_SDFAT)
  int flags = O_WRITE | O_CREAT | O_TRUNC;
  return NOODLE_FS.open(path, flags);
#else
  return NOODLE_FS.open(path, FILE_WRITE);
#endif
}
 
inline bool noodle_fs_remove(const char* path) {
    path = noodle_norm_filename(path);
#if defined(NOODLE_USE_NONE)
  (void)path;
  return false;
#else
  return NOODLE_FS.remove(path);
#endif
}
 
inline void noodle_rewind_file(NDL_File &fi) {
#if defined(NOODLE_USE_SDFAT)
  fi.seekSet(0);
#elif defined(NOODLE_USE_FFAT) || defined(NOODLE_USE_LITTLEFS) || defined(NOODLE_USE_SD_MMC) || defined(NOODLE_USE_SD)
  fi.seek(0);
#else
  // NOODLE_USE_NONE (or unknown backend): nothing to seek. Close the handle.
  fi.close();
#endif
}