Bump up SdFat version to 2.3.1

Author: JosipKuci

src/features/SdFat/BufferedPrint.h

@@ -0,0 +1,268 @@
+/**
+ * Copyright (c) 2011-2025 Bill Greiman
+ * This file is part of the SdFat library for SD memory cards.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+/**
+ * \file
+ * \brief Fast buffered print.
+ */
+#ifdef __AVR__
+#include <avr/pgmspace.h>
+#endif  // __AVR__
+#include "common/FmtNumber.h"
+/**
+ * \class BufferedPrint
+ * \brief Fast buffered print template.
+ */
+template <typename WriteClass, uint8_t BUF_DIM>
+class BufferedPrint {
+ public:
+  BufferedPrint() : m_wr(nullptr), m_in(0) {}
+  /** BufferedPrint constructor.
+   * \param[in] wr Print destination.
+   */
+  explicit BufferedPrint(WriteClass* wr) : m_wr(wr), m_in(0) {}
+  /** Initialize the BuffedPrint class.
+   * \param[in] wr Print destination.
+   */
+  void begin(WriteClass* wr) {
+    m_wr = wr;
+    m_in = 0;
+  }
+  /** Flush the buffer - same as sync() with no status return. */
+  void flush() { sync(); }
+  /** Print a character followed by a field terminator.
+   * \param[in] c character to print.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \return true for success or false if an error occurs.
+   */
+  size_t printField(char c, char term) {
+    char buf[3];
+    char* str = buf + sizeof(buf);
+    if (term) {
+      *--str = term;
+      if (term == '\n') {
+        *--str = '\r';
+      }
+    }
+    *--str = c;
+    return write(str, buf + sizeof(buf) - str);
+  }
+  /** Print a string stored in AVR flash followed by a field terminator.
+   * \param[in] fsh string to print.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \return true for success or false if an error occurs.
+   */
+  size_t printField(const __FlashStringHelper* fsh, char term) {
+#ifdef __AVR__
+    size_t rtn = 0;
+    PGM_P p = reinterpret_cast<PGM_P>(fsh);
+    char c;
+    while ((c = pgm_read_byte(p++))) {
+      if (!write(&c, 1)) {
+        return 0;
+      }
+      rtn++;
+    }
+    if (term) {
+      char buf[2];
+      char* str = buf + sizeof(buf);
+      *--str = term;
+      if (term == '\n') {
+        *--str = '\r';
+      }
+      rtn += write(str, buf + sizeof(buf) - str);
+    }
+    return rtn;
+#else   // __AVR__
+    return printField(reinterpret_cast<const char*>(fsh), term);
+#endif  // __AVR__
+  }
+  /** Print a string followed by a field terminator.
+   * \param[in] str string to print.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \return true for success or false if an error occurs.
+   */
+  size_t printField(const char* str, char term) {
+    size_t rtn = write(str, strlen(str));
+    if (term) {
+      char buf[2];
+      char* ptr = buf + sizeof(buf);
+      *--ptr = term;
+      if (term == '\n') {
+        *--ptr = '\r';
+      }
+      rtn += write(ptr, buf + sizeof(buf) - ptr);
+    }
+    return rtn;
+  }
+  /** Print a double followed by a field terminator.
+   * \param[in] d The number to be printed.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \param[in] prec Number of digits after decimal point.
+   * \return true for success or false if an error occurs.
+   */
+  size_t printField(double d, char term, uint8_t prec = 2) {
+    char buf[24];
+    char* str = buf + sizeof(buf);
+    if (term) {
+      *--str = term;
+      if (term == '\n') {
+        *--str = '\r';
+      }
+    }
+    str = fmtDouble(str, d, prec, false);
+    return write(str, buf + sizeof(buf) - str);
+  }
+  /** Print a float followed by a field terminator.
+   * \param[in] f The number to be printed.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \param[in] prec Number of digits after decimal point.
+   * \return true for success or false if an error occurs.
+   */
+  size_t printField(float f, char term, uint8_t prec = 2) {
+    return printField(static_cast<double>(f), term, prec);
+  }
+  /** Print an integer value for 8, 16, and 32 bit signed and unsigned types.
+   * \param[in] n The value to print.
+   * \param[in] term The field terminator.  Use '\\n' for CR LF.
+   * \return true for success or false if an error occurs.
+   */
+  template <typename Type>
+  size_t printField(Type n, char term) {
+    const uint8_t DIM = sizeof(Type) <= 2 ? 8 : 13;
+    char buf[DIM];
+    char* str = buf + sizeof(buf);
+
+    if (term) {
+      *--str = term;
+      if (term == '\n') {
+        *--str = '\r';
+      }
+    }
+    Type p = n < 0 ? -n : n;
+    if (sizeof(Type) <= 2) {
+      str = fmtBase10(str, static_cast<uint16_t>(p));
+    } else {
+      str = fmtBase10(str, static_cast<uint32_t>(p));
+    }
+    if (n < 0) {
+      *--str = '-';
+    }
+    return write(str, buf + sizeof(buf) - str);
+  }
+  /** Print CR LF.
+   * \return true for success or false if an error occurs.
+   */
+  size_t println() {
+    char buf[2];
+    buf[0] = '\r';
+    buf[1] = '\n';
+    return write(buf, 2);
+  }
+  /** Print a double.
+   * \param[in] d The number to be printed.
+   * \param[in] prec Number of digits after decimal point.
+   * \return true for success or false if an error occurs.
+   */
+  size_t print(double d, uint8_t prec = 2) { return printField(d, 0, prec); }
+  /** Print a double followed by CR LF.
+   * \param[in] d The number to be printed.
+   * \param[in] prec Number of digits after decimal point.
+   * \return true for success or false if an error occurs.
+   */
+  size_t println(double d, uint8_t prec = 2) {
+    return printField(d, '\n', prec);
+  }
+  /** Print a float.
+   * \param[in] f The number to be printed.
+   * \param[in] prec Number of digits after decimal point.
+   * \return true for success or false if an error occurs.
+   */
+  size_t print(float f, uint8_t prec = 2) {
+    return printField(static_cast<double>(f), 0, prec);
+  }
+  /** Print a float followed by CR LF.
+   * \param[in] f The number to be printed.
+   * \param[in] prec Number of digits after decimal point.
+   * \return true for success or false if an error occurs.
+   */
+  size_t println(float f, uint8_t prec) {
+    return printField(static_cast<double>(f), '\n', prec);
+  }
+  /** Print character, string, or number.
+   * \param[in] v item to print.
+   * \return true for success or false if an error occurs.
+   */
+  template <typename Type>
+  size_t print(Type v) {
+    return printField(v, 0);
+  }
+  /** Print character, string, or number followed by CR LF.
+   * \param[in] v item to print.
+   * \return true for success or false if an error occurs.
+   */
+  template <typename Type>
+  size_t println(Type v) {
+    return printField(v, '\n');
+  }
+
+  /** Flush the buffer.
+   * \return true for success or false if an error occurs.
+   */
+  bool sync() {
+    if (!m_wr || m_wr->write(m_buf, m_in) != m_in) {
+      return false;
+    }
+    m_in = 0;
+    return true;
+  }
+  /** Write data to an open file.
+   * \param[in] src Pointer to the location of the data to be written.
+   *
+   * \param[in] n Number of bytes to write.
+   *
+   * \return For success write() returns the number of bytes written, always
+   * \a n.
+   */
+  size_t write(const void* src, size_t n) {
+    if ((m_in + n) > sizeof(m_buf)) {
+      if (!sync()) {
+        return 0;
+      }
+      if (n >= sizeof(m_buf)) {
+        return n == m_wr->write((const uint8_t*)src, n) ? n : 0;
+      }
+    }
+    memcpy(m_buf + m_in, src, n);
+    m_in += n;
+    return n;
+  }
+
+ private:
+  WriteClass* m_wr;
+  uint8_t m_in;
+  // Insure room for double.
+  uint8_t m_buf[BUF_DIM < 24 ? 24 : BUF_DIM];  // NOLINT
+};

src/features/SdFat/CPPLINT.cfg

@@ -0,0 +1,3 @@
+filter=-build/include,-runtime/references,-build/header_guard
+filter=-whitespace/indent_namespace
+exclude_files=SdFatDebugConfig.h