rpl_info_handler.h

/* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.

   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 Free 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.  See the
   GNU General Public License for more 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 St, Fifth Floor, Boston, MA 02110-1301  USA */

#ifndef RPL_INFO_HANDLER_H
#define RPL_INFO_HANDLER_H

#include <my_global.h>
#include <dynamic_ids.h>
#include "rpl_info_values.h"

enum enum_info_repository
{
  INFO_REPOSITORY_FILE= 0,
  INFO_REPOSITORY_TABLE,
  INFO_REPOSITORY_DUMMY,
  /*
    Add new types of repository before this
    entry.
  */
  INVALID_INFO_REPOSITORY
};

/*
  Defines status on the repository.
*/
enum enum_return_check { REPOSITORY_DOES_NOT_EXIST= 1, REPOSITORY_EXISTS, ERROR_CHECKING_REPOSITORY };

class Rpl_info_handler
{
  friend class Rpl_info_factory;

public:
  int init_info()
  {
    return do_init_info();
  }

  enum_return_check check_info()
  {
    return do_check_info();
  }

  int flush_info(const bool force)
  {
    return do_flush_info(force);
  }

  int remove_info()
  {
    return do_remove_info();
  }

  int clean_info()
  {
    return do_clean_info();
  }

  void end_info()
  {
    do_end_info();
  }

  int prepare_info_for_read()
  {
    return (do_prepare_info_for_read());
  }

  int prepare_info_for_write()
  {
    return (do_prepare_info_for_write());
  }

  uint get_rpl_info_type()
  {
     return (do_get_rpl_info_type());
  }
  const char* get_rpl_info_type_str();

  template <class TypeHandler>
  bool set_info(TypeHandler const value)
  {
    if (cursor >= ninfo || prv_error)
      return TRUE;

    if (!(prv_error= do_set_info(cursor, value)))
      cursor++;

    return(prv_error);
  }

  template <class TypeHandler>
  bool set_info(TypeHandler const value, const size_t size)
  {
    if (cursor >= ninfo || prv_error)
      return TRUE;

    if (!(prv_error= do_set_info(cursor, value, size)))
      cursor++;

    return(prv_error);
  }

  template <class TypeHandlerPointer, class TypeHandler>
  bool get_info(TypeHandlerPointer value,
                TypeHandler const default_value)
  {
    if (cursor >= ninfo || prv_error)
      return TRUE;

    if (!(prv_error= do_get_info(cursor, value, default_value)))
      cursor++;

    return(prv_error);
  }

  template <class TypeHandler>
  bool get_info(TypeHandler value, const size_t size,
                TypeHandler const default_value)
  {
    if (cursor >= ninfo || prv_error)
      return TRUE;

    if (!(prv_error= do_get_info(cursor, value, size, default_value)))
      cursor++;

    return(prv_error);
  }
 
  bool get_info(Dynamic_ids *value,
                const Dynamic_ids *default_value)
  {
    if (cursor >= ninfo || prv_error)
      return TRUE;

    if (!(prv_error= do_get_info(cursor, value, default_value)))
      cursor++;

    return(prv_error);
  }

  int get_number_info() { return ninfo; }

  void set_sync_period(uint period);

  char *get_description_info()
  {
    return (do_get_description_info());
  }

  bool is_transactional() { return do_is_transactional(); }

  bool update_is_transactional() { return do_update_is_transactional(); }

  /*                                                                                                                                    
    Pre-store information before writing it to the repository and if
    necessary after reading it from the repository. The decision is
    delegated to the sub-classes.
  */
  Rpl_info_values *field_values;

  virtual ~Rpl_info_handler();

protected:
  /* Number of fields to be stored in the repository. */
  int ninfo;

  /* From/To where we should start reading/writing. */
  int cursor;

  /* Registers if there was failure while accessing a field/information. */
  bool prv_error;

  /*
   Keeps track of the number of events before fsyncing. The option
   --sync-master-info and --sync-relay-log-info determine how many
   events should be processed before fsyncing.
  */
  uint sync_counter;

  /*
   The number of events after which we should fsync.
  */
  uint sync_period;

  Rpl_info_handler(const int nparam);

private:
  virtual int do_init_info()= 0;
  virtual int do_init_info(uint instance)= 0;
  virtual enum_return_check do_check_info()= 0;
  virtual enum_return_check do_check_info(uint instance)= 0;
  virtual int do_flush_info(const bool force)= 0;
  virtual int do_remove_info()= 0;
  virtual int do_clean_info()= 0;
  virtual void do_end_info()= 0;
  virtual int do_prepare_info_for_read()= 0;
  virtual int do_prepare_info_for_write()= 0;

  virtual bool do_set_info(const int pos, const char *value)= 0;
  virtual bool do_set_info(const int pos, const uchar *value,
                           const size_t size)= 0;
  virtual bool do_set_info(const int pos, const ulong value)= 0;
  virtual bool do_set_info(const int pos, const int value)= 0;
  virtual bool do_set_info(const int pos, const float value)= 0;
  virtual bool do_set_info(const int pos, const Dynamic_ids *value)= 0;
  virtual bool do_get_info(const int pos, char *value,
                           const size_t size,
                           const char *default_value)= 0;
  virtual bool do_get_info(const int pos, uchar *value,
                           const size_t size,
                           const uchar *default_value)= 0;
  virtual bool do_get_info(const int pos, ulong *value,
                           const ulong default_value)= 0;
  virtual bool do_get_info(const int pos, int *value,
                           const int default_value)= 0;
  virtual bool do_get_info(const int pos, float *value,
                           const float default_value)= 0;
  virtual bool do_get_info(const int pos, Dynamic_ids *value,
                           const Dynamic_ids *default_value)= 0;
  virtual char* do_get_description_info()= 0;
  virtual bool do_is_transactional()= 0;
  virtual bool do_update_is_transactional()= 0;
  virtual uint do_get_rpl_info_type()= 0;

  Rpl_info_handler(const Rpl_info_handler& handler);

  Rpl_info_handler& operator=(const Rpl_info_handler& handler);
};
#ifndef DBUG_OFF
 extern ulong w_rr;
 extern uint mts_debug_concurrent_access;
#endif
#endif /* RPL_INFO_HANDLER_H */