externalizable.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * 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; either version 2 of the License, or (at your option)
 * any later version.
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_EXTERNALIZE_EXTERNALIZABLE_HPP_
#define FOEDUS_EXTERNALIZE_EXTERNALIZABLE_HPP_
#include <stdint.h>

#include <iosfwd>
#include <string>
#include <vector>

#include "foedus/cxx11.hpp"
#include "foedus/error_stack.hpp"
#include "foedus/assorted/assorted_func.hpp"
#include "foedus/assorted/fixed_string.hpp"
#include "foedus/fs/fwd.hpp"

// forward declarations for tinyxml2. They should provide a header file for this...
namespace tinyxml2 {
  class XMLDocument;
  class XMLElement;
  class XMLAttribute;
  class XMLComment;
  class XMLNode;
  class XMLText;
  class XMLDeclaration;
  class XMLUnknown;
  class XMLPrinter;
}  // namespace tinyxml2

namespace foedus {
namespace externalize {
struct Externalizable {
  virtual ErrorStack load(tinyxml2::XMLElement* element) = 0;

  virtual ErrorStack save(tinyxml2::XMLElement* element) const = 0;

  virtual const char* get_tag_name() const = 0;

  virtual void assign(const foedus::externalize::Externalizable *other) = 0;

  ErrorStack  load_from_string(const std::string& xml);

  void        save_to_stream(std::ostream* ptr) const;

  ErrorStack  load_from_file(const fs::Path &path);

  ErrorStack  save_to_file(const fs::Path &path) const;

  // convenience methods
  static ErrorStack insert_comment(tinyxml2::XMLElement* element, const std::string& comment);
  static ErrorStack append_comment(tinyxml2::XMLElement* parent, const std::string& comment);
  static ErrorStack create_element(tinyxml2::XMLElement* parent, const std::string& name,
                  tinyxml2::XMLElement** out);

  template <typename T>
  static ErrorStack add_element(tinyxml2::XMLElement* parent, const std::string& tag,
                  const std::string& comment, T value);

  template <uint MAXLEN, typename CHAR>
  static ErrorStack add_element(
    tinyxml2::XMLElement* parent,
    const std::string& tag,
    const std::string& comment,
    const assorted::FixedString<MAXLEN, CHAR>& value) {
    return add_element< std::string >(parent, tag, comment, value.str());
  }

  template <typename T>
  static ErrorStack add_element(tinyxml2::XMLElement* parent, const std::string& tag,
            const std::string& comment, const std::vector< T >& value) {
    if (comment.size() > 0) {
      CHECK_ERROR(append_comment(parent,
        tag + " (type=" + assorted::get_pretty_type_name< std::vector< T > >()
          + "): " + comment));
    }
    for (std::size_t i = 0; i < value.size(); ++i) {
      CHECK_ERROR(add_element(parent, tag, "", value[i]));
    }
    return kRetOk;
  }

  template <typename ENUM>
  static ErrorStack add_enum_element(tinyxml2::XMLElement* parent, const std::string& tag,
                const std::string& comment, ENUM value) {
    return add_element(parent, tag, comment, static_cast<int64_t>(value));
  }

  static ErrorStack add_child_element(tinyxml2::XMLElement* parent, const std::string& tag,
                  const std::string& comment, const Externalizable& child);

  template <typename T>
  static ErrorStack get_element(tinyxml2::XMLElement* parent, const std::string& tag,
                  T* out, bool optional = false, T value = 0);
  static ErrorStack get_element(tinyxml2::XMLElement* parent, const std::string& tag,
                  std::string* out, bool optional = false, const char* value = "");
  template <uint MAXLEN, typename CHAR>
  static ErrorStack get_element(
    tinyxml2::XMLElement* parent,
    const std::string& tag,
    assorted::FixedString<MAXLEN, CHAR>* out,
    bool optional = false,
    const assorted::FixedString<MAXLEN, CHAR>& value = assorted::FixedString<MAXLEN, CHAR>()) {
    std::string tmp_out;
    CHECK_ERROR(get_element(parent, tag, &tmp_out, optional, value.str().c_str()));
    out->assign(tmp_out.data(), tmp_out.size());
    return kRetOk;
  }

  template <typename ENUM>
  static ErrorStack get_enum_element(tinyxml2::XMLElement* parent, const std::string& tag,
          ENUM* out, bool optional = false, ENUM default_value = static_cast<ENUM>(0)) {
    // enum might be signged or unsigned, 1 byte, 2 byte, or 4 byte.
    // But surely it won't exceed int64_t range.
    int64_t tmp;
    CHECK_ERROR(get_element<int64_t>(parent, tag, &tmp, optional, default_value));
    if (static_cast<int64_t>(static_cast<ENUM>(tmp)) != tmp) {
      return ERROR_STACK_MSG(kErrorCodeConfValueOutofrange, tag.c_str());
    }
    *out = static_cast<ENUM>(tmp);
    return kRetOk;
  }

  template <typename T>
  static ErrorStack get_element(tinyxml2::XMLElement* parent, const std::string& tag,
            std::vector< T >* out, bool optional = false);

  static ErrorStack get_child_element(tinyxml2::XMLElement* parent, const std::string& tag,
            Externalizable* child, bool optional = false);
};

}  // namespace externalize
}  // namespace foedus

// A bit tricky to get "a" from a in C macro.
#define EX_QUOTE(str) #str
#define EX_EXPAND(str) EX_QUOTE(str)

#define EXTERNALIZE_SAVE_ELEMENT(element, attribute, comment) \
  CHECK_ERROR(add_element(element, EX_EXPAND(attribute), comment, attribute))

#define EXTERNALIZE_SAVE_ENUM_ELEMENT(element, attribute, comment) \
  CHECK_ERROR(add_enum_element(element, EX_EXPAND(attribute), comment, attribute))

#define EXTERNALIZE_LOAD_ELEMENT(element, attribute) \
  CHECK_ERROR(get_element(element, EX_EXPAND(attribute), & attribute))

#define EXTERNALIZE_LOAD_ELEMENT_OPTIONAL(element, attribute, default_value) \
  CHECK_ERROR(get_element(element, EX_EXPAND(attribute), & attribute, true, default_value))

#define EXTERNALIZE_LOAD_ENUM_ELEMENT(element, attribute) \
  CHECK_ERROR(get_enum_element(element, EX_EXPAND(attribute), & attribute))

#define EXTERNALIZE_LOAD_ENUM_ELEMENT_OPTIONAL(element, attribute, default_value) \
  CHECK_ERROR(get_enum_element(element, EX_EXPAND(attribute), & attribute, true, default_value))

#define EXTERNALIZABLE(clazz) \
  ErrorStack load(tinyxml2::XMLElement* element) CXX11_OVERRIDE;\
  ErrorStack save(tinyxml2::XMLElement* element) const CXX11_OVERRIDE;\
  const char* get_tag_name() const CXX11_OVERRIDE { return EX_EXPAND(clazz); }\
  void assign(const foedus::externalize::Externalizable *other) CXX11_OVERRIDE {\
    *this = *dynamic_cast< const clazz * >(other);\
  }\
  friend std::ostream& operator<<(std::ostream& o, const clazz & v) {\
    v.save_to_stream(&o);\
    return o;\
  }

#endif  // FOEDUS_EXTERNALIZE_EXTERNALIZABLE_HPP_