summaryrefslogtreecommitdiff
path: root/boost/contract/detail/inlined/core/exception.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/contract/detail/inlined/core/exception.hpp')
-rw-r--r--boost/contract/detail/inlined/core/exception.hpp502
1 files changed, 502 insertions, 0 deletions
diff --git a/boost/contract/detail/inlined/core/exception.hpp b/boost/contract/detail/inlined/core/exception.hpp
new file mode 100644
index 0000000000..8c3eb3ff95
--- /dev/null
+++ b/boost/contract/detail/inlined/core/exception.hpp
@@ -0,0 +1,502 @@
+
+#ifndef BOOST_CONTRACT_DETAIL_INLINED_EXCEPTION_HPP_
+#define BOOST_CONTRACT_DETAIL_INLINED_EXCEPTION_HPP_
+
+// Copyright (C) 2008-2018 Lorenzo Caminiti
+// Distributed under the Boost Software License, Version 1.0 (see accompanying
+// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
+// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
+
+// IMPORTANT: Do NOT use config macros BOOST_CONTRACT_... in this file so lib
+// .cpp does not need recompiling if config changes (recompile only user code).
+
+#include <boost/contract/core/exception.hpp>
+#include <boost/contract/detail/static_local_var.hpp>
+#include <boost/contract/detail/declspec.hpp>
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/exception/diagnostic_information.hpp>
+#include <boost/config.hpp>
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <exception>
+
+namespace boost { namespace contract {
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+exception::~exception() BOOST_NOEXCEPT_OR_NOTHROW {}
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+bad_virtual_result_cast::bad_virtual_result_cast(char const* from_type_name,
+ char const* to_type_name) {
+ std::ostringstream text;
+ text
+ << "incompatible contracted virtual function result type "
+ << "conversion from '" << from_type_name << "' to '"
+ << to_type_name << "'"
+ ;
+ what_ = text.str();
+}
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+bad_virtual_result_cast::~bad_virtual_result_cast() BOOST_NOEXCEPT_OR_NOTHROW {}
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+char const* bad_virtual_result_cast::what() const BOOST_NOEXCEPT_OR_NOTHROW {
+ return what_.c_str();
+}
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+assertion_failure::assertion_failure(char const* const file,
+ unsigned long const line, char const* const code) :
+ file_(file), line_(line), code_(code)
+{ init(); }
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+assertion_failure::assertion_failure(char const* const code) :
+ file_(""), line_(0), code_(code)
+{ init(); }
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+assertion_failure::~assertion_failure() BOOST_NOEXCEPT_OR_NOTHROW {}
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+char const* assertion_failure::what() const BOOST_NOEXCEPT_OR_NOTHROW {
+ return what_.c_str();
+}
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+char const* assertion_failure::file() const { return file_; }
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+unsigned long assertion_failure::line() const { return line_; }
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+char const* assertion_failure::code() const { return code_; }
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+void assertion_failure::init() {
+ std::ostringstream text;
+ text << "assertion";
+ if(std::string(code_) != "") text << " \"" << code_ << "\"";
+ text << " failed";
+ if(std::string(file_) != "") {
+ text << ": file \"" << file_ << "\"";
+ if(line_ != 0) text << ", line " << line_;
+ }
+ what_ = text.str();
+}
+
+namespace exception_ {
+ enum failure_key {
+ check_failure_key,
+ pre_failure_key,
+ post_failure_key,
+ except_failure_key,
+ old_failure_key,
+ entry_inv_failure_key,
+ exit_inv_failure_key
+ };
+
+ template<failure_key Key>
+ void default_handler() {
+ std::string k = "";
+ switch(Key) {
+ case check_failure_key: k = "check "; break;
+ case pre_failure_key: k = "precondition "; break;
+ case post_failure_key: k = "postcondition "; break;
+ case except_failure_key: k = "except "; break;
+ case old_failure_key: k = "old copy "; break;
+ case entry_inv_failure_key: k = "entry invariant "; break;
+ case exit_inv_failure_key: k = "exit invariant "; break;
+ // No default (so compiler warning/error on missing enum case).
+ }
+ try { throw; }
+ catch(boost::contract::assertion_failure const& error) {
+ // what = "assertion '...' failed: ...".
+ std::cerr << k << error.what() << std::endl;
+ } catch(...) { // old_failure_key prints this, not above.
+ std::cerr << k << "threw following exception:" << std::endl
+ << boost::current_exception_diagnostic_information();
+ }
+ std::terminate(); // Default handlers log and call terminate.
+ }
+
+ template<failure_key Key>
+ void default_from_handler(from) { default_handler<Key>(); }
+
+ // Check failure.
+
+ struct check_failure_mutex_tag;
+ typedef boost::contract::detail::static_local_var<check_failure_mutex_tag,
+ boost::mutex> check_failure_mutex;
+
+ struct check_failure_handler_tag;
+ typedef boost::contract::detail::static_local_var_init<
+ check_failure_handler_tag,
+ failure_handler,
+ void (*)(),
+ &default_handler<check_failure_key>
+ > check_failure_handler;
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ failure_handler const& set_check_failure_unlocked(failure_handler const& f)
+ BOOST_NOEXCEPT_OR_NOTHROW {
+ check_failure_handler::ref() = f;
+ return f;
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ failure_handler const& set_check_failure_locked(failure_handler const& f)
+ BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(check_failure_mutex::ref());
+ return set_check_failure_unlocked(f);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ failure_handler get_check_failure_unlocked() BOOST_NOEXCEPT_OR_NOTHROW {
+ return check_failure_handler::ref();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ failure_handler get_check_failure_locked() BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(check_failure_mutex::ref());
+ return get_check_failure_unlocked();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void check_failure_unlocked() /* can throw */ {
+ check_failure_handler::ref()();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void check_failure_locked() /* can throw */ {
+ boost::lock_guard<boost::mutex> lock(check_failure_mutex::ref());
+ check_failure_unlocked();
+ }
+
+ // Precondition failure.
+
+ struct pre_failure_mutex_tag;
+ typedef boost::contract::detail::static_local_var<pre_failure_mutex_tag,
+ boost::mutex> pre_failure_mutex;
+
+ struct pre_failure_handler_tag;
+ typedef boost::contract::detail::static_local_var_init<
+ pre_failure_handler_tag,
+ from_failure_handler,
+ void (*)(from),
+ &default_from_handler<pre_failure_key>
+ > pre_failure_handler;
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_pre_failure_unlocked(from_failure_handler
+ const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ pre_failure_handler::ref() = f;
+ return f;
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_pre_failure_locked(from_failure_handler
+ const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(pre_failure_mutex::ref());
+ return set_pre_failure_unlocked(f);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_pre_failure_unlocked() BOOST_NOEXCEPT_OR_NOTHROW {
+ return pre_failure_handler::ref();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_pre_failure_locked() BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(pre_failure_mutex::ref());
+ return get_pre_failure_unlocked();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void pre_failure_unlocked(from where) /* can throw */ {
+ pre_failure_handler::ref()(where);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void pre_failure_locked(from where) /* can throw */ {
+ boost::lock_guard<boost::mutex> lock(pre_failure_mutex::ref());
+ pre_failure_unlocked(where);
+ }
+
+ // Postcondition failure.
+
+ struct post_failure_mutex_tag;
+ typedef boost::contract::detail::static_local_var<post_failure_mutex_tag,
+ boost::mutex> post_failure_mutex;
+
+ struct post_failure_handler_tag;
+ typedef boost::contract::detail::static_local_var_init<
+ post_failure_handler_tag,
+ from_failure_handler,
+ void (*)(from),
+ &default_from_handler<post_failure_key>
+ > post_failure_handler;
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_post_failure_unlocked(from_failure_handler
+ const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ post_failure_handler::ref() = f;
+ return f;
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_post_failure_locked(from_failure_handler
+ const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(post_failure_mutex::ref());
+ return set_post_failure_unlocked(f);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_post_failure_unlocked() BOOST_NOEXCEPT_OR_NOTHROW {
+ return post_failure_handler::ref();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_post_failure_locked() BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(post_failure_mutex::ref());
+ return get_post_failure_unlocked();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void post_failure_unlocked(from where) /* can throw */ {
+ post_failure_handler::ref()(where);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void post_failure_locked(from where) /* can throw */ {
+ boost::lock_guard<boost::mutex> lock(post_failure_mutex::ref());
+ post_failure_unlocked(where);
+ }
+
+ // Except failure.
+
+ struct except_failure_mutex_tag;
+ typedef boost::contract::detail::static_local_var<except_failure_mutex_tag,
+ boost::mutex> except_failure_mutex;
+
+ struct except_failure_handler_tag;
+ typedef boost::contract::detail::static_local_var_init<
+ except_failure_handler_tag,
+ from_failure_handler,
+ void (*)(from),
+ &default_from_handler<except_failure_key>
+ > except_failure_handler;
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_except_failure_unlocked(from_failure_handler
+ const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ except_failure_handler::ref() = f;
+ return f;
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_except_failure_locked(from_failure_handler
+ const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(except_failure_mutex::ref());
+ return set_except_failure_unlocked(f);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_except_failure_unlocked()
+ BOOST_NOEXCEPT_OR_NOTHROW {
+ return except_failure_handler::ref();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_except_failure_locked() BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(except_failure_mutex::ref());
+ return get_except_failure_unlocked();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void except_failure_unlocked(from where) /* can throw */ {
+ except_failure_handler::ref()(where);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void except_failure_locked(from where) /* can throw */ {
+ boost::lock_guard<boost::mutex> lock(except_failure_mutex::ref());
+ except_failure_unlocked(where);
+ }
+
+ // Old-copy failure.
+
+ struct old_failure_mutex_tag;
+ typedef boost::contract::detail::static_local_var<old_failure_mutex_tag,
+ boost::mutex> old_failure_mutex;
+
+ struct old_failure_handler_tag;
+ typedef boost::contract::detail::static_local_var_init<
+ old_failure_handler_tag,
+ from_failure_handler,
+ void (*)(from),
+ &default_from_handler<old_failure_key>
+ > old_failure_handler;
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_old_failure_unlocked(from_failure_handler
+ const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ old_failure_handler::ref() = f;
+ return f;
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_old_failure_locked(from_failure_handler
+ const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(old_failure_mutex::ref());
+ return set_old_failure_unlocked(f);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_old_failure_unlocked() BOOST_NOEXCEPT_OR_NOTHROW {
+ return old_failure_handler::ref();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_old_failure_locked() BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(old_failure_mutex::ref());
+ return get_old_failure_unlocked();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void old_failure_unlocked(from where) /* can throw */ {
+ old_failure_handler::ref()(where);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void old_failure_locked(from where) /* can throw */ {
+ boost::lock_guard<boost::mutex> lock(old_failure_mutex::ref());
+ old_failure_unlocked(where);
+ }
+
+ // Entry invariant failure.
+
+ struct entry_inv_failure_mutex_tag;
+ typedef boost::contract::detail::static_local_var<
+ entry_inv_failure_mutex_tag, boost::mutex> entry_inv_failure_mutex;
+
+ struct entry_inv_failure_handler_tag;
+ typedef boost::contract::detail::static_local_var_init<
+ entry_inv_failure_handler_tag,
+ from_failure_handler,
+ void (*)(from),
+ &default_from_handler<entry_inv_failure_key>
+ > entry_inv_failure_handler;
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_entry_inv_failure_unlocked(
+ from_failure_handler const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ entry_inv_failure_handler::ref() = f;
+ return f;
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_entry_inv_failure_locked(
+ from_failure_handler const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(entry_inv_failure_mutex::ref());
+ return set_entry_inv_failure_unlocked(f);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_entry_inv_failure_unlocked()
+ BOOST_NOEXCEPT_OR_NOTHROW {
+ return entry_inv_failure_handler::ref();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_entry_inv_failure_locked()
+ BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(entry_inv_failure_mutex::ref());
+ return get_entry_inv_failure_unlocked();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void entry_inv_failure_unlocked(from where) /* can throw */ {
+ entry_inv_failure_handler::ref()(where);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void entry_inv_failure_locked(from where) /* can throw */ {
+ boost::lock_guard<boost::mutex> lock(entry_inv_failure_mutex::ref());
+ entry_inv_failure_unlocked(where);
+ }
+
+ // Exit invariant failure.
+
+ struct exit_inv_failure_mutex_tag;
+ typedef boost::contract::detail::static_local_var<
+ exit_inv_failure_mutex_tag, boost::mutex> exit_inv_failure_mutex;
+
+ struct exit_inv_failure_handler_tag;
+ typedef boost::contract::detail::static_local_var_init<
+ exit_inv_failure_handler_tag,
+ from_failure_handler,
+ void (*)(from),
+ &default_from_handler<exit_inv_failure_key>
+ > exit_inv_failure_handler;
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_exit_inv_failure_unlocked(
+ from_failure_handler const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ exit_inv_failure_handler::ref() = f;
+ return f;
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler const& set_exit_inv_failure_locked(
+ from_failure_handler const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(exit_inv_failure_mutex::ref());
+ return set_exit_inv_failure_unlocked(f);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_exit_inv_failure_unlocked()
+ BOOST_NOEXCEPT_OR_NOTHROW {
+ return exit_inv_failure_handler::ref();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ from_failure_handler get_exit_inv_failure_locked()
+ BOOST_NOEXCEPT_OR_NOTHROW {
+ boost::lock_guard<boost::mutex> lock(exit_inv_failure_mutex::ref());
+ return get_exit_inv_failure_unlocked();
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void exit_inv_failure_unlocked(from where) /* can throw */ {
+ exit_inv_failure_handler::ref()(where);
+ }
+
+ BOOST_CONTRACT_DETAIL_DECLINLINE
+ void exit_inv_failure_locked(from where) /* can throw */ {
+ boost::lock_guard<boost::mutex> lock(exit_inv_failure_mutex::ref());
+ exit_inv_failure_unlocked(where);
+ }
+}
+
+from_failure_handler const& set_entry_invariant_failure(
+ from_failure_handler const& f) BOOST_NOEXCEPT_OR_NOTHROW;
+
+from_failure_handler const& set_exit_invariant_failure(
+ from_failure_handler const& f) BOOST_NOEXCEPT_OR_NOTHROW;
+
+BOOST_CONTRACT_DETAIL_DECLINLINE
+from_failure_handler const& set_invariant_failure(
+ from_failure_handler const& f) BOOST_NOEXCEPT_OR_NOTHROW {
+ set_entry_invariant_failure(f);
+ set_exit_invariant_failure(f);
+ return f;
+}
+
+} } // namespace
+
+#endif // #include guard
+