error_stack.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_ERROR_STACK_HPP_
#define FOEDUS_ERROR_STACK_HPP_

#include <errno.h>
#include <stdint.h>

#include <cstring>
#include <iosfwd>
#include <string>

#include "foedus/assert_nd.hpp"
#include "foedus/compiler.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/error_code.hpp"

namespace foedus {

class ErrorStack {
 public:
  enum Constants {
     kMaxStackDepth = 8,
  };

  ErrorStack();

  explicit ErrorStack(ErrorCode code);

  ErrorStack(const char* filename, const char* func, uint32_t linenum, ErrorCode code,
        const char* custom_message = CXX11_NULLPTR);

  ErrorStack(const ErrorStack &other);

  ErrorStack(const ErrorStack &other, const char* filename, const char* func, uint32_t linenum,
        const char* more_custom_message = CXX11_NULLPTR);

  ErrorStack& operator=(const ErrorStack &other);

  ~ErrorStack();

  bool                is_error() const;

  ErrorCode           get_error_code() const;

  const char*         get_message() const;

  const char*         get_custom_message() const;

  void                copy_custom_message(const char* message);

  void                clear_custom_message();

  void                append_custom_message(const char* more_custom_message);

  uint16_t            get_stack_depth() const;

  uint32_t            get_linenum(uint16_t stack_index) const;

  const char*         get_filename(uint16_t stack_index) const;

  const char*         get_func(uint16_t stack_index) const;

  int                 get_os_errno() const;

  void                verify() const;

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

  void                dump_and_abort(const char *abort_message) const;
  static std::string  get_recent_dump_and_abort();


  friend std::ostream& operator<<(std::ostream& o, const ErrorStack& obj);

 private:
  const char*     filenames_[kMaxStackDepth];

  const char*     funcs_[kMaxStackDepth];

  uint32_t        linenums_[kMaxStackDepth];

  mutable const char*     custom_message_;

  int             os_errno_;

  ErrorCode       error_code_;

  uint16_t        stack_depth_;

  mutable bool    checked_;
};

const ErrorStack kRetOk;

inline ErrorStack::ErrorStack()
  : custom_message_(CXX11_NULLPTR), os_errno_(0), error_code_(kErrorCodeOk),
    stack_depth_(0), checked_(true) {
}

inline ErrorStack::ErrorStack(ErrorCode code)
  : custom_message_(CXX11_NULLPTR), os_errno_(errno), error_code_(code),
    stack_depth_(0), checked_(false) {
}

inline ErrorStack::ErrorStack(const char* filename, const char* func, uint32_t linenum,
                ErrorCode code, const char* custom_message)
  : custom_message_(CXX11_NULLPTR), os_errno_(errno), error_code_(code), stack_depth_(1),
    checked_(false) {
  ASSERT_ND(code != kErrorCodeOk);
  filenames_[0] = filename;
  funcs_[0] = func;
  linenums_[0] = linenum;
  copy_custom_message(custom_message);
}

inline ErrorStack::ErrorStack(const ErrorStack &other)
  : custom_message_(CXX11_NULLPTR) {
  operator=(other);
}

inline ErrorStack::ErrorStack(const ErrorStack &other, const char* filename,
              const char* func, uint32_t linenum, const char* more_custom_message)
  : custom_message_(CXX11_NULLPTR) {
  // Invariant: if kErrorCodeOk, no more processing
  if (LIKELY(other.error_code_ == kErrorCodeOk)) {
    this->error_code_ = kErrorCodeOk;
    return;
  }

  operator=(other);
  // augment stacktrace
  if (stack_depth_ != 0 && stack_depth_ < kMaxStackDepth) {
    filenames_[stack_depth_] = filename;
    funcs_[stack_depth_] = func;
    linenums_[stack_depth_] = linenum;
    ++stack_depth_;
  }
  // augment custom error message
  if (more_custom_message) {
    append_custom_message(more_custom_message);
  }
}

inline ErrorStack& ErrorStack::operator=(const ErrorStack &other) {
  // Invariant: if kErrorCodeOk, no more processing
  if (LIKELY(other.error_code_ == kErrorCodeOk)) {
    this->error_code_ = kErrorCodeOk;
    return *this;
  }

  // this copy assignment is actually a move assignment.
  // checked_/custom_message_ are mutable for that.
  custom_message_ = other.custom_message_;  // steal.
  other.custom_message_ = CXX11_NULLPTR;  // simply stolen. much more efficient.
  stack_depth_ = other.stack_depth_;
  for (int i = 0; i < other.stack_depth_; ++i) {
    filenames_[i] = other.filenames_[i];
    funcs_[i] = other.funcs_[i];
    linenums_[i] = other.linenums_[i];
  }
  os_errno_ = other.os_errno_;
  error_code_ = other.error_code_;
  checked_ = false;
  other.checked_ = true;
  return *this;
}

inline ErrorStack::~ErrorStack() {
  // Invariant: if kErrorCodeOk, no more processing
  if (LIKELY(error_code_ == kErrorCodeOk)) {
    return;
  }
#ifdef DEBUG
  // We output warning if some error code is not checked, but we don't do so in release mode.
  verify();
#endif  // DEBUG
  clear_custom_message();
}


inline void ErrorStack::clear_custom_message() {
  if (UNLIKELY(custom_message_)) {
    delete[] custom_message_;
    custom_message_ = CXX11_NULLPTR;
  }
}

inline void ErrorStack::copy_custom_message(const char* message) {
  // Invariant: if kErrorCodeOk, no more processing
  if (LIKELY(error_code_ == kErrorCodeOk)) {
    return;
  }

  clear_custom_message();
  if (message) {
    // do NOT use strdup to make sure new/delete everywhere.
    size_t len = std::strlen(message);
    char *copied = new char[len + 1];  // +1 for null terminator
    if (copied) {
      custom_message_ = copied;
      std::memcpy(copied, message, len + 1);
    }
  }
}

inline void ErrorStack::append_custom_message(const char* more_custom_message) {
  // Invariant: if kErrorCodeOk, no more processing
  if (LIKELY(error_code_ == kErrorCodeOk)) {
    return;
  }
  // augment custom error message
  if (custom_message_) {
    // concat
    size_t cur_len = std::strlen(custom_message_);
    size_t more_len = std::strlen(more_custom_message);
    char *copied = new char[cur_len + more_len + 1];
    if (copied) {
      custom_message_ = copied;
      std::memcpy(copied, custom_message_, cur_len);
      std::memcpy(copied + cur_len, more_custom_message, more_len + 1);
    }
  } else {
    copy_custom_message(more_custom_message);  // just put the new message
  }
}

inline bool ErrorStack::is_error() const {
  checked_ = true;
  return error_code_ != kErrorCodeOk;
}

inline ErrorCode ErrorStack::get_error_code() const {
  checked_ = true;
  return error_code_;
}

inline const char* ErrorStack::get_message() const {
  return get_error_message(error_code_);
}

inline const char* ErrorStack::get_custom_message() const {
  // Invariant: if kErrorCodeOk, no more processing
  if (error_code_ == kErrorCodeOk) {
    return CXX11_NULLPTR;
  }
  return custom_message_;
}

inline uint16_t ErrorStack::get_stack_depth() const {
  // Invariant: if kErrorCodeOk, no more processing
  if (error_code_ == kErrorCodeOk) {
    return 0;
  }
  return stack_depth_;
}

inline uint32_t ErrorStack::get_linenum(uint16_t stack_index) const {
  // Invariant: if kErrorCodeOk, no more processing
  if (error_code_ == kErrorCodeOk) {
    return 0;
  }
  ASSERT_ND(stack_index < stack_depth_);
  return linenums_[stack_index];
}

inline const char* ErrorStack::get_filename(uint16_t stack_index) const {
  // Invariant: if kErrorCodeOk, no more processing
  if (error_code_ == kErrorCodeOk) {
    return CXX11_NULLPTR;
  }
  ASSERT_ND(stack_index < stack_depth_);
  return filenames_[stack_index];
}

inline const char* ErrorStack::get_func(uint16_t stack_index) const {
  // Invariant: if kErrorCodeOk, no more processing
  if (error_code_ == kErrorCodeOk) {
    return CXX11_NULLPTR;
  }
  ASSERT_ND(stack_index < stack_depth_);
  return funcs_[stack_index];
}

inline int ErrorStack::get_os_errno() const {
  // Invariant: if kErrorCodeOk, no more processing
  if (error_code_ == kErrorCodeOk) {
    return 0;
  }
  return os_errno_;
}

inline void ErrorStack::verify() const {
  // Invariant: if kErrorCodeOk, no more processing
  if (LIKELY(error_code_ == kErrorCodeOk)) {
    return;
  }
  if (!checked_) {
    dump_and_abort("Return value is not checked. ErrorStack must be checked");
  }
}

}  // namespace foedus

// The followings are macros. So, they belong to no namespaces.

#define ERROR_STACK(e)      foedus::ErrorStack(__FILE__, __FUNCTION__, __LINE__, e)

#define ERROR_STACK_MSG(e, m)   foedus::ErrorStack(__FILE__, __FUNCTION__, __LINE__, e, m)

#define CHECK_ERROR(x)\
{\
  foedus::ErrorStack __e(x);\
  if (UNLIKELY(__e.is_error())) {\
    return foedus::ErrorStack(__e, __FILE__, __FUNCTION__, __LINE__);\
  }\
}

#define WRAP_ERROR_CODE(x)\
{\
  foedus::ErrorCode __e = x;\
  if (UNLIKELY(__e != foedus::kErrorCodeOk)) {return ERROR_STACK(__e);}\
}

#define UNWRAP_ERROR_STACK(x)\
{\
  foedus::ErrorStack __e = x;\
  if (UNLIKELY(__e.is_error())) { return __e.get_error_code(); }\
}

#define CHECK_ERROR_MSG(x, m)\
{\
  foedus::ErrorStack __e(x);\
  if (UNLIKELY(__e.is_error())) {\
    return foedus::ErrorStack(__e, __FILE__, __FUNCTION__, __LINE__, m);\
  }\
}

#define CHECK_OUTOFMEMORY(ptr)\
if (UNLIKELY(!ptr)) {\
  return foedus::ErrorStack(__FILE__, __FUNCTION__, __LINE__, kErrorCodeOutofmemory);\
}

#define COERCE_ERROR(x)\
{\
  foedus::ErrorStack __e(x);\
  if (UNLIKELY(__e.is_error())) {\
    __e.dump_and_abort("Unexpected error happened");\
  }\
}


#define COERCE_ERROR_CODE(x)\
{\
  foedus::ErrorCode __e = x;\
  if (UNLIKELY(__e != foedus::kErrorCodeOk)) {\
    ERROR_STACK(__e).dump_and_abort("Unexpected error happened");\
  }\
}

#endif  // FOEDUS_ERROR_STACK_HPP_