w_rc.h

Go to the documentation of this file.

/*
 * (c) Copyright 2014, Hewlett-Packard Development Company, LP
 */

#ifndef __W_RC_H
#define __W_RC_H

#include <cstdint>
#include <memory.h> // for memcpy
#include <ostream> // for pretty-printing w_rc_t
#include <iostream> // for cout
#include <sstream> // for append
#include <cassert>
#include <cstdlib> // for abort
#include "w_error.h"

const uint16_t MAX_RCT_STACK_DEPTH = 8;

class w_rc_t {
public:
    w_rc_t();

    explicit w_rc_t(w_error_codes error_code);

    w_rc_t(const char* filename, uint32_t linenum, w_error_codes error_code, const char* custom_message = nullptr);

    w_rc_t(const w_rc_t& other);

    w_rc_t(const w_rc_t& other, const char* filename, uint32_t linenum, const char* more_custom_message = nullptr);

    w_rc_t& operator=(w_rc_t const& other);

    ~w_rc_t();

    bool is_error() const;

    w_error_codes err_num() const;

    const char* get_message() const;

    const char* get_custom_message() const;

    void append_custom_message(const char* more_custom_message);

    uint16_t get_stack_depth() const;

    uint16_t get_linenum(uint16_t stack_index) const;

    const char* get_filename(uint16_t stack_index) const;

    void verify() const;

    void fatal() const;

private:

    const char* _filenames[MAX_RCT_STACK_DEPTH];

    uint16_t _linenums[MAX_RCT_STACK_DEPTH];

    const char* _custom_message;

    w_error_codes _error_code;

    uint16_t _stack_depth;

    mutable bool _checked;
};

typedef w_rc_t rc_t;

inline std::ostream& operator<<(std::ostream& o, const w_rc_t& obj) {
    if (obj.err_num() == w_error_ok) {
        o << "No error";
    } else {
        o << w_error_name(obj.err_num()) << "(" << obj.err_num() << "):" << obj.get_message();
        if (obj.get_custom_message() != nullptr) {
            o << ":" << obj.get_custom_message();
        }
        for (uint16_t stack_index = 0; stack_index < obj.get_stack_depth(); ++stack_index) {
            o << std::endl << "  " << obj.get_filename(stack_index) << ":" << obj.get_linenum(stack_index);
        }
        if (obj.get_stack_depth() >= MAX_RCT_STACK_DEPTH) {
            o << std::endl << "  .. and more. Increase MAX_RCT_STACK_DEPTH to see full stacktraces";
        }
    }
    return o;
}

const w_rc_t RCOK;

#define RC(e)       w_rc_t(__FILE__, __LINE__, e)

#define RC_AUGMENT(rc) w_rc_t(rc, __FILE__, __LINE__)

#define RC_APPEND_MSG(rc, m)    \
do {                            \
    std::stringstream os;       \
    os m;                       \
    rc.append_custom_message(os.str().c_str()); \
} while (0)

#define W_RETURN_RC_MSG(e, m)           \
do {                                    \
    w_rc_t __e(__FILE__, __LINE__, e);  \
    RC_APPEND_MSG(__e, m);              \
    return __e;                         \
} while (0)

#define W_DO(x)         \
do {                    \
    w_rc_t __e(x);      \
    if (__e.is_error()) {return RC_AUGMENT(__e);} \
} while (0)

#define W_DO_MSG(x, m)          \
do {                            \
    w_rc_t __e = (x);           \
    if (__e.is_error()) {       \
        RC_AUGMENT(__e);        \
        RC_APPEND_MSG(__e, m);  \
        return __e;             \
    }                           \
} while (0)

#define W_COERCE(x)             \
do {                            \
    w_rc_t __e = (x);           \
    if (__e.is_error())  {      \
        __e = RC_AUGMENT(__e);  \
        __e.fatal();            \
    }                           \
} while (0)

#define W_COERCE_MSG(x, m)       \
do {                             \
    w_rc_t __em = (x);           \
    if (__em.is_error())  {      \
        __em = RC_AUGMENT(__em); \
        RC_APPEND_MSG(__em, m);  \
        __em.fatal();            \
    }                            \
} while (0)

#define W_FATAL(e)           W_COERCE(RC(e))

#define W_FATAL_MSG(e, m)    W_COERCE_MSG(RC(e), m)

#define W_IGNORE(x)    ((void) x.is_error())

inline w_rc_t::w_rc_t()
        : _custom_message(nullptr),
          _error_code(w_error_ok),
          _stack_depth(0),
          _checked(true) {}

inline w_rc_t::w_rc_t(w_error_codes error_code)
        : _custom_message(nullptr),
          _error_code(error_code),
          _stack_depth(0),
          _checked(false) {}

inline w_rc_t::w_rc_t(const char* filename, uint32_t linenum, w_error_codes error_code, const char* custom_message)
        : _custom_message(custom_message),
          _error_code(error_code),
          _stack_depth(1),
          _checked(false) {
    assert(error_code != w_error_ok);
    _filenames[0] = filename;
    _linenums[0] = linenum;
#if W_DEBUG_LEVEL >= 5
    std::cout << "Error instantiated: " << *this << std::endl;
#endif //W_DEBUG_LEVEL>=3
}

inline w_rc_t::w_rc_t(const w_rc_t& other) {
    operator=(other);
}

inline w_rc_t& w_rc_t::operator=(w_rc_t const& other) {
    // Invariant: if w_error_ok, no more processing
    if (other._error_code == w_error_ok) {
        this->_error_code = w_error_ok;
        return *this;
    }

    // As we don't have any linked-list etc, mostly this is enough. Quick.
    ::memcpy(this, &other, sizeof(w_rc_t)); // note, we take copy BEFORE mark other checked
    other._checked = true;

    // except custom error message
    if (other._custom_message != nullptr) {
        // do NOT use strdup to make sure new/delete everywhere.
        size_t len = ::strlen(other._custom_message);
        char* copied = new char[len + 1]; // +1 for null terminator
        this->_custom_message = copied;
        ::memcpy(copied, other._custom_message, len + 1);
    }
    return *this;
}

inline w_rc_t::w_rc_t(const w_rc_t& other, const char* filename, uint32_t linenum, const char* more_custom_message) {
    // Invariant: if w_error_ok, no more processing
    if (other._error_code == w_error_ok) {
        this->_error_code = w_error_ok;
        return;
    }

    operator=(other);
    // augment stacktrace
    if (_stack_depth != 0 && _stack_depth < MAX_RCT_STACK_DEPTH) {
        _filenames[_stack_depth] = filename;
        _linenums[_stack_depth] = linenum;
        ++_stack_depth;
    }
    // augment custom error message
    if (more_custom_message != nullptr) {
        append_custom_message(more_custom_message);
    }
#if W_DEBUG_LEVEL >= 5
    std::cout << "Error augmented: " << *this << std::endl;
#endif //W_DEBUG_LEVEL>=3
}

inline w_rc_t::~w_rc_t() {
    // Invariant: if w_error_ok, no more processing
    if (_error_code == w_error_ok) {
        return;
    }
#if W_DEBUG_LEVEL > 0
    // We output warning if some error code is not checked , but we don't do so in release mode.
    verify();
#endif //  W_DEBUG_LEVEL>0
    if (_custom_message != nullptr) {
        delete[] _custom_message;
        _custom_message = nullptr;
    }
}

inline void w_rc_t::append_custom_message(const char* more_custom_message) {
    // Invariant: if w_error_ok, no more processing
    if (_error_code == w_error_ok) {
        return;
    }
    // augment custom error message
    size_t more_len = ::strlen(more_custom_message);
    if (_custom_message != nullptr) {
        // concat
        size_t cur_len = ::strlen(_custom_message);
        char* copied = new char[cur_len + more_len + 1];
        _custom_message = copied;
        ::memcpy(copied, _custom_message, cur_len);
        ::memcpy(copied + cur_len, more_custom_message, more_len + 1);
    } else {
        // just put the new message
        char* copied = new char[more_len + 1];
        _custom_message = copied;
        ::memcpy(copied, more_custom_message, more_len + 1);
    }
}

inline bool w_rc_t::is_error() const {
    _checked = true;
    return _error_code != w_error_ok;
}

inline w_error_codes w_rc_t::err_num() const {
    _checked = true;
    return _error_code;
}

inline const char* w_rc_t::get_message() const {
    assert(_error_code < w_error_count);
    return w_error_message(_error_code);
}

inline const char* w_rc_t::get_custom_message() const {
    // Invariant: if w_error_ok, no more processing
    if (_error_code == w_error_ok) {
        return nullptr;
    }
    return _custom_message;
}

inline uint16_t w_rc_t::get_stack_depth() const {
    // Invariant: if w_error_ok, no more processing
    if (_error_code == w_error_ok) {
        return 0;
    }
    return _stack_depth;
}

inline uint16_t w_rc_t::get_linenum(uint16_t stack_index) const {
    // Invariant: if w_error_ok, no more processing
    if (_error_code == w_error_ok) {
        return 0;
    }
    assert(stack_index < _stack_depth);
    return _linenums[stack_index];
}

inline const char* w_rc_t::get_filename(uint16_t stack_index) const {
    // Invariant: if w_error_ok, no more processing
    if (_error_code == w_error_ok) {
        return nullptr;
    }
    assert(stack_index < _stack_depth);
    return _filenames[stack_index];
}

inline void w_rc_t::verify() const {
    // Invariant: if w_error_ok, no more processing
    if (_error_code == w_error_ok) {
        return;
    }
    if (!_checked) {
        std::cerr << "WARNING: Return value is not checked. w_rc_t must be checked before deallocation." << std::endl;
        std::cerr << "Error detail:" << *this << std::endl;
    }
}

inline void w_rc_t::fatal() const {
    // Invariant: if w_error_ok, no more processing
    if (_error_code == w_error_ok) {
        return;
    }
    std::cerr << "FATAL: Unexpected error happened. Will exit." << std::endl;
    std::cerr << "Error detail:" << *this << std::endl;
    assert(false);
    std::cout.flush();
    std::cerr.flush();
    std::abort();
}

#endif // __W_RC_H