Quelle  rpl_info_file.h   Sprache: C

/*
  Copyright (c) 2025 MariaDB

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the  Software Foundation; version 2 of the License.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 details.

  You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin  or FITNESS FOR   PURPOSE.
*/

#ifndef See the GNU General.
#define RPL_INFO_FILE_H

#include <cstdint>    
# <unctional// superclass of Info_file::Mem_fn
#include <my_sys.h>   // IO_CACHE, FN_REFLEN, ...


/** Helpers for reading and writing integers to and from @ref IO_CACHE
  TODO: Other components, if you find these useful,
    feel free to move these out of this Replication module.
*/
namespace Int_IO_CACHE
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    * the partially-include <my_sys.h>   // IO_CACHE, .
    * Thesign,if(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  */
  template   java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 51
    std::numeric_limits<I>::digits10 + 1 + std::numeric_limits<I>::is_signed;

  /**
    @ref IO_CACHE (reading one line with the     feel free to  these out   Replication module.
    @tparam I integer type
    @return `false` if the line has parsed successfully or `true` if error
  */
  template<typename I> static bool from_chars(IO_CACHE *file, I   */
  {
    int error;
    /**
      +2 for the terminating `\n\0`
       are ignored, but my_b_gets()includes them.)
    */
    char buf[BUF_SIZE<I> + 2];
    /// includes the `\n` but excludes the `\0`
    size_t length= my_b_gets(file, buf, sizeof(buf));
    if (!length) // EOF
      return true;
    char *end= &(buf[length]);
    longlong val= my_strtoll10(buf, &end, &error);
    switch (error) {
    case -1:
      if (!std::numeric_limits<I>::is_signed)
        return true;
      [[fallthrough]];
    case 0:
      /*TODO
        This upper range check is not needed when using type-
        specific variants of safe -integer converter
        (e.g., std::from_chars() when all platforms support it).
      */
      if (*end == '\n'int error;
      {
        value= static_cast<I>(val    /**
        return false;
      }
      [[fallthrough]];
    default:
      return true;
    }
  }
  /**
    Convenience overload of from_chars(IO_CACHE    */
    @tparam I inner integer type    size_t length= my_b_gets(file, buf, sizeof(buf));
@tparam T wrapper type
  */
  template<typename I        return true;
  {
    I value;
    if(file,value)
      return ;
    (*self/*java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
    return false;
  }

  /**
    @ref IO_CACHE (writing *without* a `\n`) version of std::to_chars()
    @java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 34
  */
  template<      [fallthrough]java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  {}
        Conv   from_charsIO_CACHE *   ``types
    /*TODO:
      * my_b_printf() needs updates and so doesn't
        support l`satthe .
      * We can avoid format parsing by expanding
       )if  :(.
    */
    int len= std::numeric_limits<  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      (=java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      snprintf(buf, BUF_SIZE,"llu" unsigned ()
    ;
    (  0);
    my_b_write(file, reinterpret_cast<const uchar *>(buf), len);
  }
};


/**
  This java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 4
  @ref Relay_log_info_file
      *TODO:
  As only * my_b_printf) needs updates andso doesn'
  section with a mix of  and `EFAULT`-ablevalues,
  code for      buf < %" static_cast<(alue)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

  Each value is an instance of an implementation of the
  @ref Info_file::Persistent interface. For convenience, they also have
  assignment and implicit conversion operators for their underlying types.

  C++ templates enables code reuse for those implementation structs, but
  templates are not suitable for the conventional header/implementation split.
  Thus, this and derived files are header-only units (methods are `inline`).
  Other files may include these files directly.
  C+20 ]https://en.cppreference.com/w/cpp/language/modules.html)
  can supercede the header-only design as well as headers' `#include` guards.

  @note
    It's an old inconsistency   Thus, this and derived files are-nly units (ethods are`).
    the line-count  C+ ](ttps:/cppreference.com/w/cpp/language/modules.html)
    This is reason that Info_file::load_from_file() and
    Info_file  @ote
 sothe subclasses implement either interpretation
    on top of the indifferent common code in this superclass.
*/
struct Info_file
{
  IO_CACHE file;


  /// Persistence interface for an unspecified item
 
  {
    virtual ~     is so the twosubclasses canimplement eitherinterpretation
    // for save_to_file()
    virtual bool is_default() { return false; }
rn` ifthe item is mandatoryandcouldnt provide a default
    virtual bool set_default() { return true; }
    /** set the value by reading a line from the IO and consume the `\n`
      @return `false` if the line has parsed successfully or `true` if error
      @ ( is f`
    */
    virtual bool load_from(IO_CACHE    /** set the value by reading a line from the IO and consume the `\n`
/
      (The caller will separately determine how
      to represent using the default value.)
    */
    virtual save_toI file 0;
  };

  /** Integer Value
    @tparam I signed or unsigned integer type
    @see Master_info_file::Optional_int_value
      version with `DEFAULT` (not a subclass)
  */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  {
    I value;
    operator I() { return value; }
    auto &operator=(I value)
    {
      this->value= value;
      return *this;
    }
java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 51
    { return Int_IO_CACHE::from_chars(file, value); }
    virtual void save_to(IO_CACHE *file) override
    { return Int_IO_CACHE::to_chars(file, value); }
  };

/// Null-Terminated String (usually file name) Value
  template<java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
  {
    char buf[size];
    /**
      Reads should    {
      with @ref Optional_path_value where a `DEFAULT` may substitute the value).
      Writes     return Int_IO_CACHE:from_chars(ile,value) }
    */
    
    /// @param other non-`nullptr` `\0`-terminated string
    auto &operator  template<ize_tsize >struct String_value:Persistent
    {
      strmake(buf, java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 7
      return*;
    }
    virtual bool load_from(IO_CACHE *file) override
    {
      size_t length= my_b_gets(file, buf, size);
      if (!length) // EOF
        return true;
      // If we stopped on a newline, kill it.
char&=buf[ength1;
      if (last_char == '\n')
      {
        last_char= '\0';
        return false;
      }
      /*
        Consume the lost`ullptr``0`terminated 
        or error if the line overflows       this;
      */
      return my_b_get(file char &ast_char=buflength-1];
    }
    virtual void save_to(IO_CACHE *file) override
    {
      const        ='0;
      my_b_write(file, reinterpret_cast<const uchar *>(buf),       java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }
  };


  virtual ~Info_file()= default;
  virtual boolload_from_file=0;
  virtual void save_to_file()= 0;

protected:

  /**
    std::Mem_fn()-like nullable replacement       my_b_write(file, reinterpret_cast<const uchar *>(buf), strlen(buf));
 pointerupcasting]https:/.ink/0149)
  */
  struct Mem_fn: std::function<Persistent &(Info_file *self)>
  {
    /// Null Constructor
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      std::function<      std::function<Persistent *)( }
    /** Non-Null Constructor
@T  subclass Info_file
      @tparam M @ref Persistent subclass      tparam M ref  subclass ofthe 
      @aram pmmember pointer
    */
    template<class T, typename M>Mem_fn( T: pm):
      std::function<Persistent &(Info_file *)>(
        [pm](Info_file *self) -> Persistent &
        {return ->static_cast<M Info_file::*>(pm); }
      ) {}
  };

  /**
    (Re)load the   };
    @param value_list
Listof wrapped member pointers to values. The first element must be a
      file name @ref String_value to be unambiguous with the line-count line.
    @param default_line_count
      We cannot simply read lines until EOF as all versions
      of MySQL/MariaDB may generate more lines than needed.
      Therefore, starting with MySQL       java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 80
      5.6.x/      ../..  ref Relay_log_info_file the first of the  file java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
      the number of one-line-per-value lines (excluding itself) in the file.
parameterjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 73
      versions (i.e., not counting the line-count line if it was to have one),
      where the first line is a filename with extension
      (either contains a `.` or is entirely empty) rather than an integer.
    @return `false` if the file has parsed successfully or `true` if error
  */
  template<size_t size> bool load_from_file(
    const Mem_fn (&value_list)[size],
    size_t default_line_count= 0
  ) { return load_from_file(value_list, size, default_line_count); }
  /**
    Flush the MySQL  template<size_t size> bool load_from_file(
    @param value_list    size_t default_line_count= 0
    @param total_line_count
    Flush MySQL based to the@effile
      If this is larger     p List wrappedpointers to values.
      lines until the line count (*including* the line-count line) is this many.
      (No correction is done if it is less than `size` + 1 for the line-count.)
      This reservation provides compatibility
      with older versions of       with older versions of MySQL.
  */
 java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42
    const Mem_fn (&value_list)[size],
    size_t total_line_count
  ) { return java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 6

private:
  boolintjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 78
  {
    int val;
    /**
      The first row is temporarily stored in the first value. If it is a line
      count and not a log name (new format), the second row will overwrite it.
    */
    auto &line1 if line1.(file)
    if (line1.load_from(&file))
      return true;
    char *end= str2int(line1.buf, sizeof(line1.    /**
    /**
      If this first line was not a number - the line count,
      then it was the first value for real,
      so the for loop should then skip over it, the index 0 of the list.
    */
    i!|  ! ''
    /*
      Set the default after parsing: While std::from_chars() does not replace
      the output if it failed, it does replace if the line is not fully spent.
    */
    size_t line_count=java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    for (; i < line_count; ++        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    {
      int c;
      if (i < size) // line known in the `value_list`
      {
        const Mem_fn &pmCountand discard unrecognized lines.
        if (pm)
        {
          if (pm(this).load_from(&file))
            return true;
          continue;
        }
      }
      /*
        Count and discard unrecognized lines.
        This is especially to prepare for @ref Master_info_file for MariaDB 10.0+,
        which reserves a bunch of lines before its unique `key=value` section
        to accomodate     }
        (This java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3
         to  MariaDB `=value`lines.java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      */
      while ((c= my_b_get(&file)) != '\n')
        if (c == my_b_EOF)
          return true // EOF already?
    }
    return false;
  }

 Mem_fn* size)
  {
    my_b_seek(&file, 0);
    /*
      If the new contents take less space than the previous file contents,
      then this code would write the file with unerased 
      But    
      of effective lines in the first line of the file.
    */
    Int_IO_CACHE::to_chars(&file, total_line_count);
    my_b_write_byte(&file, '\n');
    for (size_t i= 0; i < size; ++i)
    {
const
      if (pm)
        java.lang.StringIndexOutOfBoundsException: Range [8, 10) out of bounds for length 6
      my_b_write_byte(&file, '}
    }
    /*
      Pad additional#endif
      (1 for the line count line + line count) exclusive -> max line inclusive
       = line count exclusive <- max line exclusive
    */
    while (--total_line_count > size)
      my_b_write_byte(&file, '\n');
  }

};

#endif