Boost.Contract 1.0.0

Lorenzo Caminiti lorcaminiti@gmail.com 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 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) Boost.Contract 1.0.0

Our field needs more formality, but the profession has not realized it yet.

-- Bertrand Meyer (see [Meyer97] page 400)

This library implements contract programming (a.k.a., Design by Contract or DbC) Design by Contract (DbC) is a registered trademark of the Eiffel Software company and it was first introduced by the Eiffel programming language (see [Meyer97]). for the C++ programming language. All contract programming features are supported by this library: Subcontracting, class invariants (also for static and volatile member functions), postconditions (with old and return values), preconditions, customizable actions on assertion failure (e.g., terminate the program or throw exceptions), optional compilation of assertions, disable assertions while already checking other assertions (to avoid infinite recursion), and more (see Feature Summary).

It is absurd to make elaborate security checks on debugging runs, when no trust is put in the results, and then remove them in production runs, when an erroneous result could be expensive or disastrous. What would we think of a sailing enthusiast who wears his life-jacket when training on dry land but takes it off as soon as he goes to sea?

-- Charles Antony Richard Hoare (see [Hoare73])

This section gives an overview of contract programming (see [Meyer97], [Mitchell02], and [N1613] for more extensive introductions to contract programming). Readers that already have a basic understanding of contract programming can skip this section and maybe come back to it after reading the Tutorial. The objective of this library is not to convince programmers to use contract programming. It is assumed that programmes understand the benefits and trade-offs associated with contract programming and they have already decided to use this methodology in their code. Then, this library aims to be the best and more complete contract programming library for C++ (without using programs and tools external to the C++ language and its preprocessor).

When v is present, always pass it as the first argument to boost::contract::public_function and BOOST_CONTRACT_OLDOF.

Always pass result to boost::contract::public_function right after v for non-void functions.

For the rest, considerations made in Public Functions apply to virtual public functions as well. A virtual public function should always call boost::contract::public_function (even if it has no preconditions, no postconditions, no exception guarantees, and its class has no invariants), otherwise this library will not be able to correctly use it for subcontracting.

When override_... is present, always pass it as template parameter to boost::contract::public_function.

When v is present, always pass it as the first argument to boost::contract::public_function and BOOST_CONTRACT_OLDOF.

Always pass result to boost::contract::public_function right after v for non-void functions.

At construction, the boost::contract::check RAII object for public function overrides does the following (enclosing public function override entry): Check static and non-static class invariants for all overridden bases and for the derived class in AND with each other, by calling type-of(overridden-base_1)::static_invariant() AND overridden-base_1.invariant() AND... type-of(overridden-base_n)::static_invariant() AND overridden-base_n.invariant() AND type-of(*this)::static_invariant() AND this->invariant(). Check preconditions for all overridden base functions and for the overriding derived function in OR with each other, by calling the nullary functors r_1() OR... r_n() OR r() passed to .precondition(r_1), ... .precondition(r_n), .precondition(r) for all of the overridden and overriding functions respectively. At destruction instead (enclosing public function override exit): Check static and non-static class invariants for all overridden bases and for the derived class in AND with each other, by calling type-of(overridden-base_1)::static_invariant() AND overridden-base_1.invariant() AND... type-of(overridden-base_n)::static_invariant() AND overridden-base_n.invariant() AND type-of(*this)::static_invariant() AND this->invariant() (even if the function body threw an exception). If the function body did not throw an exception: Check postconditions for all overridden base functions and for the overriding derived function in AND with each other, by calling the nullary functors s_1() AND... s_n() AND s() passed to .postcondition(s_1), ... .postcondition(s_n), .postcondition(s) for all of the overridden and overriding functions respectively (or the unary functors s_1(result) AND... s_n(result) AND s(result) for non-void public function overrides). Else: Check exception guarantees for all overridden base functions and for the overriding derived function in AND with each other, by calling the nullary functors e_1() AND... e_n() AND e() passed to .except(e_1), ... .except(e_n), .except(e) for all of the overridden and overriding functions respectively. This ensures that contracts and subcontracts of public function overrides are correctly checked at run-time in accordance with the substitution principle (see Public Function Calls). For the rest, considerations made in Virtual Public Functions apply to public function overrides as well. A public function override should always call boost::contract::public_function (even if it has no preconditions, no postconditions, no exception guarantees, and its class has no invariants), otherwise this library will not be able to correctly use it for subcontracting.

Always explicitly specify the inheritance access level public, protected, or private for base classes passed to BOOST_CONTRACT_BASE_TYPES.

See Access Specifiers to avoid making the base_types member type public. In this documentation the base_type member type is often declared public for simplicity. However, in production code it might not be acceptable to augment the public members of a class adding the base_types type (and that can be avoided using boost::contract::access as explained in Access Specifiers). See BOOST_CONTRACT_BASES_TYPEDEF to use a name different from base_types (e.g., because base_types clashes with other names in user-defined classes).

<anchor id="N1962_vector_anchor"/>[N1962] Vector: Contracts for STL vector and comparison with <link linkend="N1962_anchor">[N1962]</link> proposed syntax On compilers that support C++17 if constexpr, the following example using this library can be simplified removing boost::contract::condition_if and related functor templates such as all_of_equal_to, etc., making it more similar to the pseudo-code on the right-hand side (see Assertion Requirements). This library [N1962] proposal (not accepted in C++) plus C++17 if constexpr #include <boost/contract.hpp> #include <boost/bind.hpp> #include <boost/optional.hpp> #include <boost/algorithm/cxx11/all_of.hpp> #include <boost/type_traits/has_equal_to.hpp> #include <boost/next_prior.hpp> #include <vector> #include <functional> #include <iterator> #include <memory> #include <cassert> // Could be programmed at call site with C++14 generic lambdas. struct all_of_equal_to { typedef bool result_type; template<typename InputIter, typename T> result_type operator()(InputIter first, InputIter last, T const& value) { return boost::algorithm::all_of_equal(first, last, value); } template<typename InputIter> result_type operator()(InputIter first, InputIter last, InputIter where) { for(InputIter i = first, j = where; i != last; ++i, ++j) { if(*i != *j) return false; } return true; } }; template<typename Iter> bool valid(Iter first, Iter last); // Cannot implement in C++ (for axiom only). template<typename Iter> bool contained(Iter first1, Iter last1, Iter first2, Iter last2); // For axiom. // STL vector requires T copyable but not equality comparable. template<typename T, class Allocator = std::allocator<T> > class vector { friend class boost::contract::access; void invariant() const { BOOST_CONTRACT_ASSERT(empty() == (size() == 0)); BOOST_CONTRACT_ASSERT(std::distance(begin(), end()) == int(size())); BOOST_CONTRACT_ASSERT(std::distance(rbegin(), rend()) == int(size())); BOOST_CONTRACT_ASSERT(size() <= capacity()); BOOST_CONTRACT_ASSERT(capacity() <= max_size()); } public: typedef typename std::vector<T, Allocator>::allocator_type allocator_type; typedef typename std::vector<T, Allocator>::pointer pointer; typedef typename std::vector<T, Allocator>::const_pointer const_pointer; typedef typename std::vector<T, Allocator>::reference reference; typedef typename std::vector<T, Allocator>::const_reference const_reference; typedef typename std::vector<T, Allocator>::value_type value_type; typedef typename std::vector<T, Allocator>::iterator iterator; typedef typename std::vector<T, Allocator>::const_iterator const_iterator; typedef typename std::vector<T, Allocator>::size_type size_type; typedef typename std::vector<T, Allocator>::difference_type difference_type; typedef typename std::vector<T, Allocator>::reverse_iterator reverse_iterator; typedef typename std::vector<T, Allocator>::const_reverse_iterator const_reverse_iterator; vector() : vect_() { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(empty()); }) ; } explicit vector(Allocator const& alloc) : vect_(alloc) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(empty()); BOOST_CONTRACT_ASSERT(get_allocator() == alloc); }) ; } explicit vector(size_type count) : vect_(count) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == count); BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(all_of_equal_to(), begin(), end(), T()) ) ); }) ; } vector(size_type count, T const& value) : vect_(count, value) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == count); BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(all_of_equal_to(), begin(), end(), boost::cref(value)) ) ); }) ; } vector(size_type count, T const& value, Allocator const& alloc) : vect_(count, value, alloc) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == count); BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(all_of_equal_to(), begin(), end(), boost::cref(value)) ) ); BOOST_CONTRACT_ASSERT(get_allocator() == alloc); }) ; } template<typename InputIter> vector(InputIter first, InputIter last) : vect_(first, last) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(std::distance(first, last) == int(size())); }) ; } template<typename InputIter> vector(InputIter first, InputIter last, Allocator const& alloc) : vect_(first, last, alloc) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(std::distance(first, last) == int(size())); BOOST_CONTRACT_ASSERT(get_allocator() == alloc); }) ; } /* implicit */ vector(vector const& other) : vect_(other.vect_) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(std::equal_to<vector<T> >(), boost::cref(*this), boost::cref(other)) ) ); }) ; } vector& operator=(vector const& other) { boost::optional<vector&> result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(std::equal_to<vector<T> >(), boost::cref(*this), boost::cref(other)) ) ); BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(std::equal_to<vector<T> >(), boost::cref(*result), boost::cref(*this)) ) ); }) ; if(this != &other) vect_ = other.vect_; return *(result = *this); } virtual ~vector() { // Check invariants. boost::contract::check c = boost::contract::destructor(this); } void reserve(size_type count) { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(count < max_size()); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(capacity() >= count); }) ; vect_.reserve(count); } size_type capacity() const { size_type result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(result >= size()); }) ; return result = vect_.capacity(); } iterator begin() { iterator result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { if(empty()) BOOST_CONTRACT_ASSERT(result == end()); }) ; return result = vect_.begin(); } const_iterator begin() const { const_iterator result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { if(empty()) BOOST_CONTRACT_ASSERT(result == end()); }) ; return result = vect_.begin(); } iterator end() { // Check invariants. boost::contract::check c = boost::contract::public_function(this); return vect_.end(); } const_iterator end() const { // Check invariants. boost::contract::check c = boost::contract::public_function(this); return vect_.end(); } reverse_iterator rbegin() { iterator result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { if(empty()) BOOST_CONTRACT_ASSERT(result == rend()); }) ; return result = vect_.rbegin(); } const_reverse_iterator rbegin() const { const_reverse_iterator result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { if(empty()) BOOST_CONTRACT_ASSERT(result == rend()); }) ; return result = vect_.rbegin(); } reverse_iterator rend() { // Check invariants. boost::contract::check c = boost::contract::public_function(this); return vect_.rend(); } const_reverse_iterator rend() const { // Check invariants. boost::contract::check c = boost::contract::public_function(this); return vect_.rend(); } void resize(size_type count, T const& value = T()) { boost::contract::old_ptr<size_type> old_size = BOOST_CONTRACT_OLDOF(size()); boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == count); if(count > *old_size) { BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(all_of_equal_to(), begin() + *old_size, end(), boost::cref(value)) ) ); } }) ; vect_.resize(count, value); } size_type size() const { size_type result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(result <= capacity()); }) ; return result = vect_.size(); } size_type max_size() const { size_type result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(result >= capacity()); }) ; return result = vect_.max_size(); } bool empty() const { bool result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(result == (size() == 0)); }) ; return result = vect_.empty(); } Allocator get_allocator() const { // Check invariants. boost::contract::check c = boost::contract::public_function(this); return vect_.get_allocator(); } reference at(size_type index) { // Check invariants, no pre (throw out_of_range for invalid index). boost::contract::check c = boost::contract::public_function(this); return vect_.at(index); } const_reference at(size_type index) const { // Check invariants, no pre (throw out_of_range for invalid index). boost::contract::check c = boost::contract::public_function(this); return vect_.at(index); } reference operator[](size_type index) { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(index < size()); }) ; return vect_[index]; } const_reference operator[](size_type index) const { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(index < size()); }) ; return vect_[index]; } reference front() { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(!empty()); }) ; return vect_.front(); } const_reference front() const { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(!empty()); }) ; return vect_.front(); } reference back() { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(!empty()); }) ; return vect_.back(); } const_reference back() const { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(!empty()); }) ; return vect_.back(); } void push_back(T const& value) { boost::contract::old_ptr<size_type> old_size = BOOST_CONTRACT_OLDOF(size()); boost::contract::old_ptr<size_type> old_capacity = BOOST_CONTRACT_OLDOF(capacity()); boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(size() < max_size()); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == *old_size + 1); BOOST_CONTRACT_ASSERT(capacity() >= *old_capacity); BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(std::equal_to<T>(), boost::cref(back()), boost::cref(value)) ) ); }) ; vect_.push_back(value); } void pop_back() { boost::contract::old_ptr<size_type> old_size = BOOST_CONTRACT_OLDOF(size()); boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(!empty()); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == *old_size - 1); }) ; vect_.pop_back(); } template<typename InputIter> void assign(InputIter first, InputIter last) { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT_AXIOM( !contained(begin(), end(), first, last)); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(std::distance(first, last) == int(size())); }) ; vect_.assign(first, last); } void assign(size_type count, T const& value) { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(count <= max_size()); }) .postcondition([&] { BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(all_of_equal_to(), begin(), end(), boost::cref(value)) ) ); }) ; vect_.assign(count, value); } iterator insert(iterator where, T const& value) { iterator result; boost::contract::old_ptr<size_type> old_size = BOOST_CONTRACT_OLDOF(size()); boost::contract::old_ptr<size_type> old_capacity = BOOST_CONTRACT_OLDOF(capacity()); boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(size() < max_size()); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == *old_size + 1); BOOST_CONTRACT_ASSERT(capacity() >= *old_capacity); BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(std::equal_to<T>(), boost::cref(*result), boost::cref(value)) ) ); if(capacity() > *old_capacity) { BOOST_CONTRACT_ASSERT_AXIOM(!valid(begin(), end())); } else { BOOST_CONTRACT_ASSERT_AXIOM(!valid(where, end())); } }) ; return result = vect_.insert(where, value); } void insert(iterator where, size_type count, T const& value) { boost::contract::old_ptr<size_type> old_size = BOOST_CONTRACT_OLDOF(size()); boost::contract::old_ptr<size_type> old_capacity = BOOST_CONTRACT_OLDOF(capacity()); boost::contract::old_ptr<iterator> old_where = BOOST_CONTRACT_OLDOF(where); boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(size() + count < max_size()); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == *old_size + count); BOOST_CONTRACT_ASSERT(capacity() >= *old_capacity); if(capacity() == *old_capacity) { BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(all_of_equal_to(), boost::prior(*old_where), boost::prior(*old_where) + count, boost::cref(value) ) ) ); BOOST_CONTRACT_ASSERT_AXIOM(!valid(where, end())); } else BOOST_CONTRACT_ASSERT_AXIOM(!valid(begin(), end())); }) ; vect_.insert(where, count, value); } template<typename InputIter> void insert(iterator where, InputIter first, InputIter last) { boost::contract::old_ptr<size_type> old_size = BOOST_CONTRACT_OLDOF(size()); boost::contract::old_ptr<size_type> old_capacity = BOOST_CONTRACT_OLDOF(capacity()); boost::contract::old_ptr<iterator> old_where = BOOST_CONTRACT_OLDOF(where); boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(size() + std::distance(first, last) < max_size()); BOOST_CONTRACT_ASSERT_AXIOM( !contained(first, last, begin(), end())); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == *old_size() + std::distance(first, last)); BOOST_CONTRACT_ASSERT(capacity() >= *old_capacity); if(capacity() == *old_capacity) { BOOST_CONTRACT_ASSERT( boost::contract::condition_if<boost::has_equal_to<T> >( boost::bind(all_of_equal_to(), first, last, *old_where) ) ); BOOST_CONTRACT_ASSERT_AXIOM(!valid(where, end())); } else BOOST_CONTRACT_ASSERT_AXIOM(!valid(begin(), end())); }) ; vect_.insert(where, first, last); } iterator erase(iterator where) { iterator result; boost::contract::old_ptr<size_type> old_size = BOOST_CONTRACT_OLDOF(size()); boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(!empty()); BOOST_CONTRACT_ASSERT(where != end()); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == *old_size - 1); if(empty()) BOOST_CONTRACT_ASSERT(result == end()); BOOST_CONTRACT_ASSERT_AXIOM(!valid(where, end())); }) ; return result = vect_.erase(where); } iterator erase(iterator first, iterator last) { iterator result; boost::contract::old_ptr<size_type> old_size = BOOST_CONTRACT_OLDOF(size()); boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(size() >= std::distance(first, last)); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == *old_size - std::distance(first, last)); if(empty()) BOOST_CONTRACT_ASSERT(result == end()); BOOST_CONTRACT_ASSERT_AXIOM(!valid(first, last)); }) ; return result = vect_.erase(first, last); } void clear() { boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(empty()); }) ; vect_.clear(); } void swap(vector& other) { boost::contract::old_ptr<vector> old_me, old_other; #ifdef BOOST_CONTRACT_AUDITS old_me = BOOST_CONTRACT_OLDOF(*this); old_other = BOOST_CONTRACT_OLDOF(other); #endif boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(get_allocator() == other.get_allocator()); }) .postcondition([&] { BOOST_CONTRACT_ASSERT_AUDIT( boost::contract::condition_if<boost::has_equal_to< vector<T> > >( boost::bind(std::equal_to<vector<T> >(), boost::cref(*this), boost::cref(*old_other)) ) ); BOOST_CONTRACT_ASSERT_AUDIT( boost::contract::condition_if<boost::has_equal_to< vector<T> > >( boost::bind(std::equal_to<vector<T> >(), boost::cref(other), boost::cref(*old_me)) ) ); }) ; vect_.swap(other); } friend bool operator==(vector const& left, vector const& right) { // Check class invariants for left and right objects. boost::contract::check left_inv = boost::contract::public_function(&left); boost::contract::check right_inv = boost::contract::public_function(&right); return left.vect_ == right.vect_; } private: std::vector<T, Allocator> vect_; }; int main() { // char type has operator==. vector<char> v(3); assert(v.size() == 3); assert(boost::algorithm::all_of_equal(v, '\0')); vector<char> const& cv = v; assert(cv == v); vector<char> w(v); assert(w == v); typename vector<char>::iterator i = v.begin(); assert(*i == '\0'); typename vector<char>::const_iterator ci = cv.begin(); assert(*ci == '\0'); v.insert(i, 2, 'a'); assert(v[0] == 'a'); assert(v[1] == 'a'); v.push_back('b'); assert(v.back() == 'b'); struct x {}; // x type doest not have operator==. vector<x> y(3); assert(y.size() == 3); vector<x> const& cy = y; vector<x> z(y); typename vector<x>::iterator j = y.begin(); assert(j != y.end()); typename vector<x>::const_iterator cj = cy.begin(); assert(cj != cy.end()); y.insert(j, 2, x()); y.push_back(x()); return 0; } // Extra spaces, newlines, etc. for visual alignment with this library code. #include <boost/algorithm/cxx11/all_of.hpp> #include <boost/type_traits/has_equal_to.hpp> #include <boost/next_prior.hpp> #include <vector> #include <iterator> #include <memory> template< class T, class Allocator = std::allocator<T> > class vector { invariant { empty() == (size() == 0); std::distance(begin(), end()) == int(size()); std::distance(rbegin(), rend()) == int(size()); size() <= capacity(); capacity() <= max_size(); } public: typedef typename std::vector<T, Allocator>::allocator_type allocator_type; typedef typename std::vector<T, Allocator>::pointer pointer; typedef typename std::vector<T, Allocator>::const_pointer const_pointer; typedef typename std::vector<T, Allocator>::reference reference; typedef typename std::vector<T, Allocator>::const_reference const_reference; typedef typename std::vector<T, Allocator>::value_type value_type; typedef typename std::vector<T, Allocator>::iterator iterator; typedef typename std::vector<T, Allocator>::const_iterator const_iterator; typedef typename std::vector<T, Allocator>::size_type size_type; typedef typename std::vector<T, Allocator>::difference_type difference_type; typedef typename std::vector<T, Allocator>::reverse_iterator reverse_iterator; typedef typename std::vector<T, Allocator>::const_reverse_iterator const_reverse_iterator; vector() postcondition { empty(); } : vect_() {} explicit vector(Allocator const& alloc) postcondition { empty(); get_allocator() == alloc; } : vect_(alloc) {} explicit vector(size_type count) postcondition { size() == count; if constexpr(boost::has_equal_to<T>::value) { boost::algorithm::all_of_equal(begin(), end(), T()); } } : vect_(count) {} vector(size_type count, T const& value) postcondition { size() == count; if constexpr(boost::has_equal_to<T>::value) { boost::algorithm::all_of_equal(begin(), end(), value); } } : vect_(count, value) {} vector(size_type count, T const& value, Allocator const& alloc) postcondition { size() == count; if constexpr(boost::has_equal_to<T>::value) { boost::algorithm::all_of_equal(begin(), end(), value); } get_allocator() == alloc; } : vect_(count, value, alloc) {} template<typename InputIter> vector(InputIter first, InputIter last) postcondition { std::distance(first, last) == int(size()); } : vect_(first, last) {} template<typename InputIter> vector(InputIter first, InputIter last, Allocator const& alloc) postcondition { std::distance(first, last) == int(size()); get_allocator() == alloc; } : vect_(first, last, alloc) {} /* implicit */ vector(vector const& other) postcondition { if constexpr(boost::has_equal_to<T>::value) { *this == other; } } : vect_(other.vect_) {} vector& operator=(vector const& other) postcondition(result) { if constexpr(boost::has_equal_to<T>::value) { *this == other; result == *this; } } { if(this != &other) vect_ = other.vect_; return *this; } virtual ~vector() {} void reserve(size_type count) precondition { count < max_size(); } postcondition { capacity() >= count; } { vect_.reserve(count); } size_type capacity() const postcondition(result) { result >= size(); } { return vect_.capacity(); } iterator begin() postcondition { if(empty()) result == end(); } { return vect_.begin(); } const_iterator begin() const postcondition(result) { if(empty()) result == end(); } { return vect_.begin(); } iterator end() { return vect_.end(); } const_iterator end() const { return vect_.end(); } reverse_iterator rbegin() postcondition(result) { if(empty()) result == rend(); } { return vect_.rbegin(); } const_reverse_iterator rbegin() const postcondition(result) { if(empty()) result == rend(); } { return vect_.rbegin(); } reverse_iterator rend() { return vect_.rend(); } const_reverse_iterator rend() const { return vect_.rend(); } void resize(size_type count, T const& value = T()) postcondition { size() == count; if constexpr(boost::has_equal_to<T>::value) { if(count > oldof(size())) { boost::algorithm::all_of_equal(begin() + oldof(size()), end(), value); } } } { vect_.resize(count, value); } size_type size() const postcondition(result) { result <= capacity(); } { return vect_.size(); } size_type max_size() const postcondition(result) { result >= capacity(); } { return vect_.max_size(); } bool empty() const postcondition(result) { result == (size() == 0); } { return vect_.empty(); } Alloctor get_allocator() const { return vect_.get_allocator(); } reference at(size_type index) { // No precondition (throw out_of_range for invalid index). return vect_.at(index); } const_reference at(size_type index) const { // No precondition (throw out_of_range for invalid index). return vect_.at(index); } reference operator[](size_type index) precondition { index < size(); } { return vect_[index]; } const_reference operator[](size_type index) const precondition { index < size(); } { return vect_[index]; } reference front() precondition { !empty(); } { return vect_.front(); } const_reference front() const precondition { !empty(); } { return vect_.front(); } reference back() precondition { !empty(); } { return vect_.back(); } const_reference back() const precondition { !empty(); } { return vect_.back(); } void push_back(T const& value) precondition { size() < max_size(); } postcondition { size() == oldof(size()) + 1; capacity() >= oldof(capacity()) if constexpr(boost::has_equal_to<T>::value) { back() == value; } } { vect_.push_back(value); } void pop_back() precondition { !empty(); } postcondition { size() == oldof(size()) - 1; } { vect_.pop_back(); } template<typename InputIter> void assign(InputIter first, InputIter last) // Precondition: [begin(), end()) does not contain [first, last). postcondition { std::distance(first, last) == int(size()); } { vect_.assign(first, last); } void assign(size_type count, T const& vallue) precondition { count <= max_size(); } postcondition { if constexpr(boost::has_equal_to<T>::value) { boost::algorithm::all_of_equal(begin(), end(), value); } } { vect_.assign(count, value); } iterator insert(iterator where, T const& value) precondition { size() < max_size(); } postcondition(result) { size() == oldof(size()) + 1; capacity() >= oldof(capacity()); if constexpr(boost::has_equal_to<T>::value) { *result == value; } // if(capacity() > oldof(capacity())) // [begin(), end()) is invalid // else // [where, end()) is invalid } { return vect_.insert(where, value); } void insert(iterator where, size_type count, T const& value) precondition { size() + count < max_size(); } postcondition { size() == oldof(size()) + count; capacity() >= oldof(capacity()); if(capacity() == oldof(capacity())) { if constexpr(boost::has_equal_to<T>::value) { boost::algorithm::all_of_equal(boost::prior(oldof(where)), boost::prior(oldof(where)) + count, value); } // [where, end()) is invalid } // else [begin(), end()) is invalid } { vect_.insert(where, count, value); } template<typename InputIter> void insert(iterator where, Iterator first, Iterator last) precondition { size() + std::distance(first, last) < max_size(); // [first, last) is not contained in [begin(), end()) } postcondition { size() == oldof(size()) + std::distance(first, last); capacity() >= oldof(capacity()); if(capacity() == oldof(capacity())) { if constexpr(boost::has_equal_to<T>::value) { boost::algorithm::all_of_equal(first, last, oldof(where)); } // [where, end()) is invalid } // else [begin(), end()) is invalid } { vect_.insert(where, first, last); } iterator erase(iterator where) precondition { !empty(); where != end(); } postcondition(result) { size() == oldod size() - 1; if(empty()) result == end(); // [where, end()) is invalid } { return vect_.erase(where); } iterator erase(iterator first, iterator last) precondition { size() >= std::distance(first, lasst); } postcondition(result) { size() == oldof(size()) - std::distance(first, last); if(empty()) result == end(); // [first, last) is invalid } { return vect_.erase(first, last); } void clear() postcondition { empty(); } { vect_.clear(); } void swap(vector& other) precondition { get_allocator() == other.get_allocator(); } postcondition { if constexpr(boost::has_equal_to<T>::value) { *this == oldof(other); other == oldof(*this); } } { vect_.swap(other); } friend bool operator==(vector const& left, vector const& right) { // Cannot check class invariants for left and right objects. return left.vect_ == right.vect_; } private: std::vector<T, Allocator> vect_; }; // End.

<anchor id="N1962_factorial_anchor"/><link linkend="boost_contract.examples.__n1962___factorial__recursion">[N1962] Factorial: Recursion</link> #include <boost/contract.hpp> #include <cassert> int factorial(int n) { int result; boost::contract::check c = boost::contract::function() .precondition([&] { BOOST_CONTRACT_ASSERT(n >= 0); // Non-negative natural number. BOOST_CONTRACT_ASSERT(n <= 12); // Max function input. }) .postcondition([&] { BOOST_CONTRACT_ASSERT(result >= 1); if(n < 2) { // Select assertion. BOOST_CONTRACT_ASSERT(result == 1); } else { // Assertions automatically disabled in other assertions. // Therefore, this postcondition can recursively call the // function without causing infinite recursion. BOOST_CONTRACT_ASSERT_AUDIT(n * factorial(n - 1)); } }) ; return n < 2 ? (result = 1) : (result = n * factorial(n - 1)); } int main() { assert(factorial(4) == 24); return 0; }

<anchor id="N1962_square_root_anchor"/><link linkend="boost_contract.examples.__n1962___square_root__default_parameters_and_comparison_with_d_syntax">[N1962] Square Root: Default parameters and comparison with D syntax</link> This Library The D Programming Language #include <boost/contract.hpp> #include <cmath> #include <cassert> long lsqrt(long x) { long result; boost::contract::check c = boost::contract::function() .precondition([&] { BOOST_CONTRACT_ASSERT(x >= 0); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(result * result <= x); BOOST_CONTRACT_ASSERT((result + 1) * (result + 1) > x); }) ; return result = long(std::sqrt(double(x))); } int main() { assert(lsqrt(4) == 2); return 0; } // Extra spaces, newlines, etc. for visual alignment with this library code. long lsqrt(long x) in { assert(x >= 0); } out(result) { assert(result * result <= x); assert((result + 1) * (result + 1) > x); } do { return cast(long)std.math.sqrt(cast(real)x); } // End.

<anchor id="Meyer97_stack4_anchor"/><link linkend="boost_contract.examples.__meyer97___stack4__comparison_with_eiffel_syntax">[Meyer97] Stack4: Comparison with Eiffel syntax</link> This Library The Eiffel Programming Language // File: stack4.hpp #ifndef STACK4_HPP_ #define STACK4_HPP_ #include <boost/contract.hpp> // Dispenser with LIFO access policy and fixed max capacity. template<typename T> class stack4 #define BASES private boost::contract::constructor_precondition<stack4<T> > : BASES { friend boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES void invariant() const { BOOST_CONTRACT_ASSERT(count() >= 0); // Count non-negative. BOOST_CONTRACT_ASSERT(count() <= capacity()); // Count bounded. BOOST_CONTRACT_ASSERT(empty() == (count() == 0)); // Empty if no elem. } public: /* Initialization */ // Allocate static from a maximum of n elements. explicit stack4(int n) : boost::contract::constructor_precondition<stack4>([&] { BOOST_CONTRACT_ASSERT(n >= 0); // Non-negative capacity. }) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(capacity() == n); // Capacity set. }) ; capacity_ = n; count_ = 0; array_ = new T[n]; } // Deep copy via constructor. /* implicit */ stack4(stack4 const& other) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(capacity() == other.capacity()); BOOST_CONTRACT_ASSERT(count() == other.count()); BOOST_CONTRACT_ASSERT_AXIOM(*this == other); }) ; capacity_ = other.capacity_; count_ = other.count_; array_ = new T[other.capacity_]; for(int i = 0; i < other.count_; ++i) array_[i] = other.array_[i]; } // Deep copy via assignment. stack4& operator=(stack4 const& other) { boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(capacity() == other.capacity()); BOOST_CONTRACT_ASSERT(count() == other.count()); BOOST_CONTRACT_ASSERT_AXIOM(*this == other); }) ; delete[] array_; capacity_ = other.capacity_; count_ = other.count_; array_ = new T[other.capacity_]; for(int i = 0; i < other.count_; ++i) array_[i] = other.array_[i]; return *this; } // Destroy this stack. virtual ~stack4() { // Check invariants. boost::contract::check c = boost::contract::destructor(this); delete[] array_; } /* Access */ // Max number of stack elements. int capacity() const { // Check invariants. boost::contract::check c = boost::contract::public_function(this); return capacity_; } // Number of stack elements. int count() const { // Check invariants. boost::contract::check c = boost::contract::public_function(this); return count_; } // Top element. T const& item() const { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(!empty()); // Not empty (i.e., count > 0). }) ; return array_[count_ - 1]; } /* Status Report */ // Is stack empty? bool empty() const { bool result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { // Empty definition. BOOST_CONTRACT_ASSERT(result == (count() == 0)); }) ; return result = (count_ == 0); } // Is stack full? bool full() const { bool result; boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT( // Full definition. result == (count() == capacity())); }) ; return result = (count_ == capacity_); } /* Element Change */ // Add x on top. void put(T const& x) { boost::contract::old_ptr<int> old_count = BOOST_CONTRACT_OLDOF(count()); boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(!full()); // Not full. }) .postcondition([&] { BOOST_CONTRACT_ASSERT(!empty()); // Not empty. BOOST_CONTRACT_ASSERT(item() == x); // Added to top. BOOST_CONTRACT_ASSERT(count() == *old_count + 1); // One more. }) ; array_[count_++] = x; } // Remove top element. void remove() { boost::contract::old_ptr<int> old_count = BOOST_CONTRACT_OLDOF(count()); boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(!empty()); // Not empty (i.e., count > 0). }) .postcondition([&] { BOOST_CONTRACT_ASSERT(!full()); // Not full. BOOST_CONTRACT_ASSERT(count() == *old_count - 1); // One less. }) ; --count_; } /* Friend Helpers */ friend bool operator==(stack4 const& left, stack4 const& right) { boost::contract::check inv1 = boost::contract::public_function(&left); boost::contract::check inv2 = boost::contract::public_function(&right); if(left.count_ != right.count_) return false; for(int i = 0; i < left.count_; ++i) { if(left.array_[i] != right.array_[i]) return false; } return true; } private: int capacity_; int count_; T* array_; // Internally use C-style array. }; #endif // #include guard -- Extra spaces, newlines, etc. for visual alignment with this library code. indexing destription: "Dispenser with LIFO access policy and a fixed max capacity." class interface STACK4[G] creation make -- Interface only (no implementation). invariant count_non_negative: count >= 0 count_bounded: count <= capacity empty_if_no_elements: empty = (count = 0) feature -- Initialization -- Allocate stack for a maximum of n elements. make(n: INTEGER) is require non_negative_capacity: n >= 0 ensure capacity_set: capacity = n end feature -- Access -- Max number of stack elements. capacity: INTEGER -- Number of stack elements. count: INTEGER -- Top element. item: G is require not_empty: not empty -- i.e., count > 0 end feature -- Status report -- Is stack empty? empty: BOOLEAN is ensure empty_definition: result = (count = 0) end -- Is stack full? full: BOOLEAN is ensure full_definition: result = (count = capacity) end feature -- Element change -- Add x on top. put(x: G) is require not_full: not full ensure not_empty: not empty added_to_top: item = x one_more_item: count = old count + 1 end -- Remove top element. remove is require not_empty: not empty -- i.e., count > 0 ensure not_full: not full one_fewer_item: count = old count - 1 end end -- class interface STACK4 -- End. #include "stack4.hpp" #include <cassert> int main() { stack4<int> s(3); assert(s.capacity() == 3); assert(s.count() == 0); assert(s.empty()); assert(!s.full()); s.put(123); assert(!s.empty()); assert(!s.full()); assert(s.item() == 123); s.remove(); assert(s.empty()); assert(!s.full()); return 0; }

<anchor id="Mitchell02_counter_anchor"/><link linkend="boost_contract.examples.__mitchell02___counter__subcontracting">[Mitchell02] Counter: Subcontracting</link> #ifndef PUSH_BUTTON_HPP_ #define PUSH_BUTTON_HPP_ #include <boost/contract.hpp> #include <cassert> class push_button { public: // No inv and no bases so contracts optional if no pre, post, and override. /* Creation */ // Create an enabled button. push_button() : enabled_(true) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(enabled()); // Enabled. }) ; } // Destroy button. virtual ~push_button() { // Could have omitted contracts here (nothing to check). boost::contract::check c = boost::contract::destructor(this); } /* Queries */ // If button is enabled. bool enabled() const { // Could have omitted contracts here (nothing to check). boost::contract::check c = boost::contract::public_function(this); return enabled_; } /* Commands */ // Enable button. void enable() { boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(enabled()); // Enabled. }) ; enabled_ = true; } // Disable button. void disable() { boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(!enabled()); // Disabled. }) ; enabled_ = false; } // Invoke externally when button clicked. virtual void on_bn_clicked(boost::contract::virtual_* v = 0) = 0; private: bool enabled_; }; void push_button::on_bn_clicked(boost::contract::virtual_* v) { boost::contract::check c = boost::contract::public_function(v, this) .precondition([&] { BOOST_CONTRACT_ASSERT(enabled()); // Enabled. }) ; assert(false); } #endif // #include guard #ifndef DECREMENT_BUTTON_HPP_ #define DECREMENT_BUTTON_HPP_ #include "push_button.hpp" #include "counter.hpp" #include "../observer/observer.hpp" #include <boost/contract.hpp> #include <boost/noncopyable.hpp> class decrement_button #define BASES public push_button, public observer, \ private boost::noncopyable : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES BOOST_CONTRACT_OVERRIDES(on_bn_clicked, up_to_date_with_subject, update); public: /* Creation */ explicit decrement_button(counter& a_counter) : counter_(a_counter) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { // Enable iff positive value. BOOST_CONTRACT_ASSERT(enabled() == (a_counter.value() > 0)); }) ; counter_.attach(this); } // Destroy button. virtual ~decrement_button() { // Could have omitted contracts here (nothing to check). boost::contract::check c = boost::contract::destructor(this); } /* Commands */ virtual void on_bn_clicked(boost::contract::virtual_* v = 0) /* override */ { boost::contract::old_ptr<int> old_value = BOOST_CONTRACT_OLDOF(v, counter_.value()); boost::contract::check c = boost::contract::public_function< override_on_bn_clicked >(v, &decrement_button::on_bn_clicked, this) .postcondition([&] { // Counter decremented. BOOST_CONTRACT_ASSERT(counter_.value() == *old_value - 1); }) ; counter_.decrement(); } virtual bool up_to_date_with_subject(boost::contract::virtual_* v = 0) const /* override */ { bool result; boost::contract::check c = boost::contract::public_function< override_up_to_date_with_subject >(v, result, &decrement_button::up_to_date_with_subject, this); return result = true; // For simplicity, assume always up-to-date. } virtual void update(boost::contract::virtual_* v = 0) /* override */ { boost::contract::check c = boost::contract::public_function< override_update>(v, &decrement_button::update, this) .postcondition([&] { // Enabled iff positive value. BOOST_CONTRACT_ASSERT(enabled() == (counter_.value() > 0)); }) ; if(counter_.value() == 0) disable(); else enable(); } private: counter& counter_; }; #endif // #include guard #ifndef COUNTER_HPP_ #define COUNTER_HPP_ #include "../observer/subject.hpp" #include <boost/contract.hpp> class counter #define BASES public subject : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES public: /* Creation */ // Construct counter with specified value. explicit counter(int a_value = 10) : value_(a_value) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(value() == a_value); // Value set. }) ; } // Destroy counter. virtual ~counter() { // Could have omitted contracts here (nothing to check). boost::contract::check c = boost::contract::destructor(this); } /* Queries */ // Current counter value. int value() const { // Could have omitted contracts here (nothing to check). boost::contract::check c = boost::contract::public_function(this); return value_; } /* Commands */ // Decrement counter value. void decrement() { boost::contract::old_ptr<int> old_value = BOOST_CONTRACT_OLDOF(value()); boost::contract::check c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(value() == *old_value - 1); // Decrement. }) ; --value_; notify(); // Notify all attached observers. } private: int value_; }; #endif // #include guard #include "counter/counter.hpp" #include "counter/decrement_button.hpp" #include "observer/observer.hpp" #include <cassert> int test_counter; class view_of_counter #define BASES public observer : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES BOOST_CONTRACT_OVERRIDES(up_to_date_with_subject, update) public: /* Creation */ // Create view associated with given counter. explicit view_of_counter(counter& a_counter) : counter_(a_counter) { // Could have omitted contracts here (nothing to check). boost::contract::check c = boost::contract::constructor(this); counter_.attach(this); assert(counter_.value() == test_counter); } // Destroy view. virtual ~view_of_counter() { // Could have omitted contracts here (nothing to check). boost::contract::check c = boost::contract::destructor(this); } /* Commands */ virtual bool up_to_date_with_subject(boost::contract::virtual_* v = 0) const /* override */ { bool result; boost::contract::check c = boost::contract::public_function< override_up_to_date_with_subject >(v, result, &view_of_counter::up_to_date_with_subject, this); return result = true; // For simplicity, assume always up-to-date. } virtual void update(boost::contract::virtual_* v = 0) /* override */ { boost::contract::check c = boost::contract::public_function< override_update>(v, &view_of_counter::update, this); assert(counter_.value() == test_counter); } private: counter& counter_; }; int main() { counter cnt(test_counter = 1); view_of_counter view(cnt); decrement_button dec(cnt); assert(dec.enabled()); test_counter--; dec.on_bn_clicked(); assert(!dec.enabled()); return 0; }

<anchor id="Cline90_vector_anchor"/><link linkend="boost_contract.examples.__cline90___vector__comparison_with_a___proposal_syntax">[Cline90] Vector: Comparison with A++ proposal syntax</link> This Library A++ Proposal (never actually implemented) #ifndef VECTOR_HPP_ #define VECTOR_HPP_ #include <boost/contract.hpp> // NOTE: Incomplete contract assertions, addressing only `size`. template<typename T> class vector #define BASES private boost::contract::constructor_precondition<vector<T> > : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES void invariant() const { BOOST_CONTRACT_ASSERT(size() >= 0); } public: explicit vector(int count = 10) : boost::contract::constructor_precondition<vector>([&] { BOOST_CONTRACT_ASSERT(count >= 0); }), data_(new T[count]), size_(count) { boost::contract::check c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == count); }) ; for(int i = 0; i < size_; ++i) data_[i] = T(); } virtual ~vector() { boost::contract::check c = boost::contract::destructor(this); delete[] data_; } int size() const { boost::contract::check c = boost::contract::public_function(this); return size_; // Non-negative result already checked by invariant. } void resize(int count) { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(count >= 0); }) .postcondition([&] { BOOST_CONTRACT_ASSERT(size() == count); }) ; T* slice = new T[count]; for(int i = 0; i < count && i < size_; ++i) slice[i] = data_[i]; delete[] data_; data_ = slice; size_ = count; } T& operator[](int index) { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(index >= 0); BOOST_CONTRACT_ASSERT(index < size()); }) ; return data_[index]; } T const& operator[](int index) const { boost::contract::check c = boost::contract::public_function(this) .precondition([&] { BOOST_CONTRACT_ASSERT(index >= 0); BOOST_CONTRACT_ASSERT(index < size()); }) ; return data_[index]; } private: T* data_; int size_; }; #endif // #include guard // Extra spaces, newlines, etc. for visual alignment with this library code. template<typename T> class vector { legal: // Class invariants (legal). size() >= 0; public: explicit vector(int count = 10) : data_(new T[count]), size_(count) { for(int i = 0; i < size_; ++i) data_[i] = T(); } virtual ~vector() { delete[] data_; } int size() const { return size_; } void resize(int count) { T* slice = new T[count]; for(int i = 0; i < count && i < size_; ++i) slice[i] = data_[i]; delete[] data_; data_ = slice; size_ = count; } T& operator[](int index) { return data_[index]; } T& operator[](int index) const { return data_[index]; } axioms: // Preconditions (require) and postconditions (promise) for each func. [int count; require count >= 0; promise size() == count] vector(count); [int count; require count >= 0; promise size() == count] resize(count); [int index; require index >= 0 && index < size()] (*this)[x]; // Op[]. [int index; require index >= 0 && index < size()] (*this)[x] const; // Op[]. private: T* data_; int size_; }; // End. #include "vector.hpp" #include <cassert> int main() { vector<int> v (3); assert(v.size() == 3); v[0] = 123; v.resize(2); assert(v[0] == 123); assert(v.size() == 2); return 0; }

Reference

Header <<ulink url="../../../../boost/contract.hpp">boost/contract.hpp</ulink>>Include all header files required by this library at once (for convenience). All header files boost/contract/*.hpp are independent from one another and can be included one-by-one to reduce the amount of code to compile from this library in user code (but this was measured to not make an appreciable difference in compile-time so boost/contract.hpp can be included directly in most cases). Instead the headers boost/contract/core/*.hpp are not independent from other library headers and they are automatically included by the boost/contract/*.hpp headers (so the boost/contract/core/*.hpp headers are usually not directly included by programmers).All files under the boost/contract/detail/ directory, names within the boost::contract::detail namespace, names prefixed by boost_contract_detail... and BOOST_CONTRACT_DETAIL... (in any namesapce, including user's code) are reserved for internal use of this library and should never be used directly by programmers.See Also: Getting Started

Header <<ulink url="../../../../boost/contract/assert.hpp">boost/contract/assert.hpp</ulink>>Assert contract conditions. BOOST_CONTRACT_ASSERT(cond) BOOST_CONTRACT_ASSERT_AUDIT(cond) BOOST_CONTRACT_ASSERT_AXIOM(cond) Macro BOOST_CONTRACT_ASSERT3BOOST_CONTRACT_ASSERTPreferred way to assert contract conditions. // In header: <boost/contract/assert.hpp> BOOST_CONTRACT_ASSERT(cond)DescriptionAny exception thrown from within a contract (preconditions, postconditions, exception guarantees, old value copies at body, class invariants, etc.) is interpreted by this library as a contract failure. Therefore, users can program contract assertions manually throwing an exception when an asserted condition is checked to be false (this library will then call the appropriate contract failure handler boost::contract::precondition_failure, etc.). However, it is preferred to use this macro because it expands to code that throws boost::contract::assertion_failure with the correct assertion file name (using __FILE__), line number (using __LINE__), and asserted condition code so to produce informative error messages (C++11 __func__ is not used here because in most cases it will simply expand to the internal compiler name of the lambda function used to program the contract conditions adding no specificity to the error message). BOOST_CONTRACT_ASSERT, BOOST_CONTRACT_ASSERT_AUDIT, and BOOST_CONTRACT_ASSERT_AXIOM are the three assertion levels predefined by this library.See Also: Preconditions, Postconditions, Exceptions Guarantees, Class Invariants, No Macros Parameters:condBoolean contract condition to check. (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and BOOST_CONTRACT_ASSERT((cond)) will always work.) Macro BOOST_CONTRACT_ASSERT_AUDIT3BOOST_CONTRACT_ASSERT_AUDITPreferred way to assert contract conditions that are computationally expensive, at least compared to the computational cost of executing the function body. // In header: <boost/contract/assert.hpp> BOOST_CONTRACT_ASSERT_AUDIT(cond)DescriptionThe asserted condition will always be compiled and validated syntactically, but it will not be checked at run-time unless BOOST_CONTRACT_AUDITS is defined (undefined by default). This macro is defined by code equivalent to:#ifdef BOOST_CONTRACT_AUDITS #define BOOST_CONTRACT_ASSERT_AUDIT(cond) \ BOOST_CONTRACT_ASSERT(cond) #else #define BOOST_CONTRACT_ASSERT_AUDIT(cond) \ BOOST_CONTRACT_ASSERT(true || cond) #endif BOOST_CONTRACT_ASSERT, BOOST_CONTRACT_ASSERT_AUDIT, and BOOST_CONTRACT_ASSERT_AXIOM are the three assertion levels predefined by this library. If there is a need, programmers are free to implement their own assertion levels defining macros similar to the one above.See Also: Assertion Levels, No Macros Parameters:condBoolean contract condition to check. (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and BOOST_CONTRACT_ASSERT_AUDIT((cond)) will always work.) Macro BOOST_CONTRACT_ASSERT_AXIOM3BOOST_CONTRACT_ASSERT_AXIOMPreferred way to document in the code contract conditions that are computationally prohibitive, at least compared to the computational cost of executing the function body. // In header: <boost/contract/assert.hpp> BOOST_CONTRACT_ASSERT_AXIOM(cond)DescriptionThe asserted condition will always be compiled and validated syntactically, but it will never be checked at run-time. This macro is defined by code equivalent to:#define BOOST_CONTRACT_ASSERT_AXIOM(cond) \ BOOST_CONTRACT_ASSERT(true || cond) BOOST_CONTRACT_ASSERT, BOOST_CONTRACT_ASSERT_AUDIT, and BOOST_CONTRACT_ASSERT_AXIOM are the three assertion levels predefined by this library. If there is a need, programmers are free to implement their own assertion levels defining macros similar to the one above.See Also: Assertion Levels, No Macros Parameters:condBoolean contract condition to check. (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and BOOST_CONTRACT_ASSERT_AXIOM((cond)) will always work.)

Header <<ulink url="../../../../boost/contract/base_types.hpp">boost/contract/base_types.hpp</ulink>>Specify inheritance form base classes (for subcontracting). BOOST_CONTRACT_BASE_TYPES(...) Macro BOOST_CONTRACT_BASE_TYPES3BOOST_CONTRACT_BASE_TYPESUsed to program the typedef that lists the bases of a derived class. // In header: <boost/contract/base_types.hpp> BOOST_CONTRACT_BASE_TYPES(...)DescriptionIn order to support subcontracting, a derived class that specifies contracts for one or more overriding public functions must declare a typedef named base_types (or BOOST_CONTRACT_BASES_TYPEDEF) using this macro:class u #define BASES public b, protected virtual w1, private w2 : BASES { friend class boost::contract:access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES ... }; This typedef must be public unless boost::contract::access is used.See Also: Base Classes Parameters:...Comma separated list of base classes. Each base must explicitly specify its access specifier public, protected, or private, and also virtual when present (this not always required in C++ instead). There is a limit of about 20 maximum bases that can be listed (because of similar limits in Boost.MPL internally used by this library). This is a variadic macro parameter, on compilers that do not support variadic macros, the typedef for base classes can be programmed manually without using this macro (see No Macros).

Header <<ulink url="../../../../boost/contract/call_if.hpp">boost/contract/call_if.hpp</ulink>>Statically disable compilation and execution of functor calls. These facilities allow to emulate C++17 if constexpr statements when used together with functor templates (and C++14 generic lambdas). Therefore, they are not useful on C++17 compilers where if constexpr can be directly used instead. namespace boost { namespace contract { template<bool Pred, typename Then, typename ThenResult = internal_type> struct call_if_statement; template<typename Then> struct call_if_statement<false, Then, internal_type>; template<typename Then> struct call_if_statement<true, Then, internal_type>; template<typename Then, typename ThenResult> struct call_if_statement<true, Then, ThenResult>; template<typename Then> struct call_if_statement<true, Then, void>; template<bool Pred, typename Then> call_if_statement< Pred, Then > call_if_c(Then); template<typename Pred, typename Then> call_if_statement< Pred::value, Then > call_if(Then); template<bool Pred, typename Then> bool condition_if_c(Then, bool = true); template<typename Pred, typename Then> bool condition_if(Then, bool = true); } } Struct template call_if_statement3boost::contract::call_if_statementSelect compilation and execution of functor template calls using a static boolean predicate (not needed on C++17 compilers, use if constexpr instead). // In header: <boost/contract/call_if.hpp> template<bool Pred, typename Then, typename ThenResult = internal_type> struct call_if_statement { };DescriptionThis class template has no members because it is never used directly, it is only used via its specializations. Usually this class template is instantiated only via the return value of boost::contract::call_if and boost::contract::call_if_c.See Also: Assertion Requirements Template Parametersbool PredStatic boolean predicate that selects which functor template call to compile and execute. typename ThenType of the functor template to call if the static predicate Pred is true. typename ThenResult = internal_typeReturn type of then-branch functor template call (this is usually automatically deduced by this library so it is never explicitly specified by the user, and that is why it is often marked as internal_type in this documentation). Struct template call_if_statement<false, Then, internal_type>3boost::contract::call_if_statement<false, Then, internal_type>Template specialization to handle static predicates that are false (not needed on C++17 compilers, use if constexpr instead). // In header: <boost/contract/call_if.hpp> template<typename Then> struct call_if_statement<false, Then, internal_type> { // construct/copy/destruct explicit call_if_statement(Then const &); // public member functions template<typename Else> result_of< Else()>::type else_(Else) const; template<bool ElseIfPred, typename ElseIfThen> call_if_statement< ElseIfPred, ElseIfThen > else_if_c(ElseIfThen) const; template<typename ElseIfPred, typename ElseIfThen> call_if_statement< ElseIfPred::value, ElseIfThen > else_if(ElseIfThen) const; };DescriptionThis template specialization handles all else-branch functor template calls (whether they return void or not). Usually this class template is instantiated only via the return value of boost::contract::call_if and boost::contract::call_if_c.See Also: Assertion Requirements Template Parameterstypename ThenType of functor template to call when the static predicate is true (never the case for this template specialization). <anchor id="boost.contract.call_if__idm45395000098448construct-copy-destruct"/><computeroutput>call_if_statement</computeroutput> public construct/copy/destructexplicit call_if_statement(Then const & f);Construct this object with the then-branch functor template. Parameters:fThen-branch nullary functor template. The functor template call f() is never compiled or executed for this template specialization (because the if-statement static predicate is false). The return type of f() must be the same as (or implicitly convertible to) the return type of all other functor template calls specified for this call-if object. <anchor id="idm45395000089616-bb"/><computeroutput>call_if_statement</computeroutput> public member functionstemplate<typename Else> result_of< Else()>::type else_(Else f) const;Specify the else-branch functor template. The result_of<Else()>::type expression needs be evaluated only when the static predicate is already checked to be false (because Else() is required to compile only in that case). Thus, this result-of expression is evaluated lazily and only in instantiations of this template specialization. Parameters:fElse-branch nullary functor template. The functor template call f() is actually compiled and executed for this template specialization (because the if-statement static predicate is false). The return type of f() must be the same as (or implicitly convertible to) the return type of all other functor template calls specified for this call-if object.Returns:A copy of the value returned by the call to the else-branch functor template f(). template<bool ElseIfPred, typename ElseIfThen> call_if_statement< ElseIfPred, ElseIfThen > else_if_c(ElseIfThen f) const;Specify an else-if-branch functor template (using a static boolean predicate). Parameters:fElse-if-branch nullary functor template. The functor template call f() is actually compiled and executed if and only if ElseIfPred is true (because the if-statement static predicate is already false for this template specialization). The return type of f() must be the same as (or implicitly convertible to) the return type of all other functor template calls specified for this call-if object.Template Parameters:ElseIfPredStatic boolean predicate selecting which functor template call to compile and execute.Returns:A call-if statement so the else statement and additional else-if statements can be specified if needed. Eventually, this will be the return value of the one functor template call being compiled and executed. template<typename ElseIfPred, typename ElseIfThen> call_if_statement< ElseIfPred::value, ElseIfThen > else_if(ElseIfThen f) const;Specify an else-if-branch functor template (using a nullary boolen meta-function). Parameters:fElse-if-branch nullary functor template. The functor template call f() is actually compiled and executed if and only if ElseIfPred::value is true (because the if-statement static predicate is already false for this template specialization). The return type of f() must be the same as (or implicitly convertible to) the return type of all other functor template calls specified for this call-if object.Template Parameters:ElseIfPredNullary boolean meta-function selecting which functor template call to compile and execute.Returns:A call-if statement so the else statement and additional else-if statements can be specified if needed. Eventually, this will be the return value of the one functor template call being compiled and executed. Struct template call_if_statement<true, Then, internal_type>3boost::contract::call_if_statement<true, Then, internal_type>Template specialization to dispatch between then-branch functor template calls that return void and the ones that return non-void (not needed on C++17 compilers, use if constexpr instead). // In header: <boost/contract/call_if.hpp> template<typename Then> struct call_if_statement<true, Then, internal_type> : public boost::contract::call_if_statement< true, Then, result_of< Then()>::type > { // construct/copy/destruct explicit call_if_statement(Then); };DescriptionThe base class is a call-if statement so the else and else-if statements can be specified if needed. Usually this class template is instantiated only via the return value of boost::contract::call_if and boost::contract::call_if_c.The result_of<Then()>::type expression needs be evaluated only when the static predicate is already checked to be true (because Then() is required to compile only in that case). Thus, this template specialization introduces an extra level of indirection necessary for proper lazy evaluation of this result-of expression. See Also: Assertion Requirements Template Parameterstypename ThenType of functor template to call when the static predicate is true (as it is for this template specialization). <anchor id="boost.contract.call_if__idm45395000058976construct-copy-destruct"/><computeroutput>call_if_statement</computeroutput> public construct/copy/destructexplicit call_if_statement(Then f);Construct this object with the then-branch functor template. Parameters:fThen-branch nullary functor template. The functor template call f() is compiled and called for this template specialization (because the if-statement static predicate is true). The return type of f() must be the same as (or implicitly convertible to) the return type of all other functor template calls specified for this call-if object. Struct template call_if_statement<true, Then, ThenResult>3boost::contract::call_if_statement<true, Then, ThenResult>Template specialization to handle static predicates that are true for then-branch functor template calls that do not return void (not needed on C++17 compilers, use if constexpr instead). // In header: <boost/contract/call_if.hpp> template<typename Then, typename ThenResult> struct call_if_statement<true, Then, ThenResult> { // construct/copy/destruct explicit call_if_statement(Then); // public member functions operator ThenResult() const; template<typename Else> ThenResult else_(Else const &) const; template<bool ElseIfPred, typename ElseIfThen> call_if_statement< true, Then, ThenResult > else_if_c(ElseIfThen const &) const; template<typename ElseIfPred, typename ElseIfThen> call_if_statement< true, Then, ThenResult > else_if(ElseIfThen const &) const; };DescriptionUsually this class template is instantiated only via the return value of boost::contract::call_if and boost::contract::call_if_c.See Also: Assertion Requirements Template Parameterstypename ThenType of functor template to call when the static predicate is true (as it is for this template specialization). typename ThenResultNon-void return type of the then-branch functor template call. <anchor id="boost.contract.call_if__idm45395000042848construct-copy-destruct"/><computeroutput>call_if_statement</computeroutput> public construct/copy/destructexplicit call_if_statement(Then f);Construct this object with the then-branch functor template. Parameters:fThen-branch nullary functor template. The functor template call f() is actually compiled and executed for this template specialization (because the if-statement static predicate is true). The return type of f() must be the same as (or implicitly convertible to) the ThenResult type. <anchor id="idm45395000033040-bb"/><computeroutput>call_if_statement</computeroutput> public member functionsoperator ThenResult() const;This implicit type conversion returns a copy of the value returned by the call to the then-branch functor template. template<typename Else> ThenResult else_(Else const & f) const;Specify the else-branch functor template. Parameters:fElse-branch nullary functor template. The functor template call f() is never compiled or executed for this template specialization (because the if-statement static predicate is true). The return type of f() must be the same as (or implicitly convertible to) the ThenResult type.Returns:A copy of the value returned by the call to the then-branch functor template (because the else-branch functor template call is not executed). template<bool ElseIfPred, typename ElseIfThen> call_if_statement< true, Then, ThenResult > else_if_c(ElseIfThen const & f) const;Specify an else-if-branch functor template (using a static boolean predicate). Parameters:fElse-if-branch nullary functor template. The functor template call f() is never compiled or executed for this template specialization (because the if-statement static predicate is true). The return type of f() must be the same as (or implicitly convertible to) the ThenResult type.Template Parameters:ElseIfPredStatic boolean predicate selecting which functor template call to compile and execute.Returns:A call-if statement so the else statement and additional else-if statements can be specified if needed. Eventually, it will be the return value of the then-branch functor template call for this template specialization (because the if-statement static predicate is true). template<typename ElseIfPred, typename ElseIfThen> call_if_statement< true, Then, ThenResult > else_if(ElseIfThen const & f) const;Specify an else-if-branch functor template (using a nullary boolean meta-function). Parameters:fElse-if-branch nullary functor template. The functor template call f() is never compiled or executed for this template specialization (because the if-statement static predicate is true). The return type of f() must be the same as (or implicitly convertible to) the ThenResult type.Template Parameters:ElseIfPredNullary boolean meta-function selecting which functor template call to compile and execute.Returns:A call-if statement so the else statement and additional else-if statements can be specified if needed. Eventually, it will be the return value of the then-branch functor template call for this template specialization (because the if-statement static predicate is true). Struct template call_if_statement<true, Then, void>3boost::contract::call_if_statement<true, Then, void>Template specialization to handle static predicates that are true for then-branch functor template calls that return void (not needed on C++17 compilers, use if constexpr instead). // In header: <boost/contract/call_if.hpp> template<typename Then> struct call_if_statement<true, Then, void> { // construct/copy/destruct explicit call_if_statement(Then); // public member functions template<typename Else> void else_(Else const &) const; template<bool ElseIfPred, typename ElseIfThen> call_if_statement< true, Then, void > else_if_c(ElseIfThen const &) const; template<typename ElseIfPred, typename ElseIfThen> call_if_statement< true, Then, void > else_if(ElseIfThen const &) const; };DescriptionUsually this class template is instantiated only via the return value of boost::contract::call_if and boost::contract::call_if_c.See Also: Assertion Requirements Template Parameterstypename ThenType of functor template to call when the static predicate if true (as it is for this template specialization). <anchor id="boost.contract.call_if__idm45395000002720construct-copy-destruct"/><computeroutput>call_if_statement</computeroutput> public construct/copy/destructexplicit call_if_statement(Then f);Construct this object with the then-branch functor template. Parameters:fThen-branch nullary functor template. The functor template call f() is actually compiled and executed for this template specialization (because the if-statement static predicate is true). The return type of f() must be void for this template specialization (because the then-branch functor template calls return void). <anchor id="idm45394999993936-bb"/><computeroutput>call_if_statement</computeroutput> public member functionstemplate<typename Else> void else_(Else const & f) const;Specify the else-branch functor template. Parameters:fElse-branch nullary functor template. The functor template call f() is never compiled or executed for this template specialization (because the if-statement static predicate is true). The return type of f() must be void for this template specialization (because the then-branch functor template calls return void). template<bool ElseIfPred, typename ElseIfThen> call_if_statement< true, Then, void > else_if_c(ElseIfThen const & f) const;Specify an else-if-branch functor template (using a static boolean predicate). Parameters:fElse-if-branch nullary functor template. The functor template call f() is never compiled or executed for this template specialization (because the if-statement static predicate is true). The return type of f() must be void for this template specialization (because the then-branch functor template calls return void).Template Parameters:ElseIfPredStatic boolean predicate selecting which functor template call to compile and execute.Returns:A call-if statement so the else statement and additional else-if statements can be specified if needed. Eventually, it will return void for this template specialization (because the then-branch functor template calls return void). template<typename ElseIfPred, typename ElseIfThen> call_if_statement< true, Then, void > else_if(ElseIfThen const & f) const;Specify an else-if-branch functor template (using a nullary boolean meta-function). Parameters:fElse-if-branch nullary functor template. The functor template call f() is never compiled or executed for this template specialization (because the if-statement static predicate is true). The return type of f() must be void for this template specialization (because the then-branch functor template calls return void).Template Parameters:ElseIfPredNullary boolean meta-function selecting which functor template call to compile and execute.Returns:A call-if statement so the else statement and additional else-if statements can be specified if needed. Eventually, it will return void for this template specialization (because the then-branch functor template calls return void). Function template call_if_c3boost::contract::call_if_cSelect compilation and execution of functor template calls using a static boolean predicate (not needed on C++17 compilers, use if constexpr instead). // In header: <boost/contract/call_if.hpp> template<bool Pred, typename Then> call_if_statement< Pred, Then > call_if_c(Then f);DescriptionCreate a call-if object with the specified then-branch functor template:boost::contract::call_if_c<Pred1>( then_functor_template1 ).template else_if_c<Pred2>( // Optional. then_functor_template2 ) // Optionally, other `else_if_c` or ... // `else_if`. .else_( // Optional for `void` functors, else_functor_template // but required for non `void`. ) Optional functor templates for else-if-branches and the else-branch can be specified as needed (the else-branch function template is required if f returns non-void).See Also: Assertion Requirements Parameters:fThen-branch nullary functor template. The functor template call f() is compiled and executed if and only if Pred is true. The return type of other functor template calls specified for this call-if statement (else-branch, else-if-branches, etc.) must be the same as (or implicitly convertible to) the return type of then-branch functor call f().Template Parameters:PredStatic boolean predicate selecting which functor template call to compile and execute.Returns:A call-if statement so else and else-if statements can be specified if needed. Eventually, this will be the return value of the one functor template call being compiled and executed (which could also be void). Function template call_if3boost::contract::call_ifSelect compilation and execution of functor template calls using a nullary boolean meta-function (not needed on C++17 compilers, use if constexpr instead). // In header: <boost/contract/call_if.hpp> template<typename Pred, typename Then> call_if_statement< Pred::value, Then > call_if(Then f);DescriptionThis is equivalent to boost::contract::call_if_c<Pred::value>(f). Create a call-if object with the specified then-branch functor template:boost::contract::call_if<Pred1>( then_functor_template1 ).template else_if<Pred2>( // Optional. then_functor_template2 ) // Optionally, other `else_if` or ... // `else_if_c`. .else_( // Optional for `void` functors, else_functor_template // but required for non `void`. ) Optional functor templates for else-if-branches and the else-branch can be specified as needed (the else-branch functor template is required if f returns non-void).See Also: Assertion Requirements Parameters:fThen-branch nullary functor template. The functor template call f() is compiled and executed if and only if Pred::value is true. The return type of other functor template calls specified for this call-if statement (else-branch, else-if-branches, etc.) must be the same as (or implicitly convertible to) the return type of then-branch functor template call f().Template Parameters:PredNullary boolean meta-function selecting which functor template call to compile and execute.Returns:A call-if statement so else and else-if statements can be specified if needed. Eventually, this will be the return value of the one functor template call being compiled and executed (which could also be void). Function template condition_if_c3boost::contract::condition_if_cSelect compilation and execution of a boolean functor template condition using a static boolean predicate (not needed on C++17 compilers, use if constexpr instead). // In header: <boost/contract/call_if.hpp> template<bool Pred, typename Then> bool condition_if_c(Then f, bool else_ = true);DescriptionCompile and execute the nullary boolean functor template call f() if and only if the specified static boolean predicate Pred is true, otherwise trivially return else_ (true by default) at run-time.A call to boost::contract::condition_if_c<Pred>(f, else_) is logically equivalent to boost::contract::call_if_c<Pred>(f, [] { return else_; }) (but its internal implementation is optimized and it does not actually use call_if_c).See Also: Assertion Requirements Parameters:else_Boolean value to return when Pred is false (instead of compiling and executing the functor template call f()).fNullary boolean functor template. The functor template call f() is compiled and executed if and only if Pred is true.Template Parameters:PredStatic boolean predicate selecting when the functor template call f() should be compiled and executed. Returns:Boolean value returned by f() if the static predicate Pred is true. Otherwise, trivially return else_. Function template condition_if3boost::contract::condition_ifSelect compilation and execution of a boolean functor template condition using a nullary boolean meta-function (not needed on C++17 compilers, use if constexpr instead). // In header: <boost/contract/call_if.hpp> template<typename Pred, typename Then> bool condition_if(Then f, bool else_ = true);DescriptionThis is equivalent to boost::contract::condition_if_c<Pred::value>(f, else_). Compile and execute the nullary boolean functor template call f() if and only if the specified nullary boolean meta-function Pred::value is true, otherwise trivially return else_ (true by default) at run-time.See Also: Assertion Requirements Parameters:else_Boolean value to return when Pred::value is false (instead of compiling and executing the functor template call f()).fNullary boolean functor template. The functor template call f() is compiled and executed if and only if Pred::value is true. Template Parameters:PredNullary boolean meta-function selecting when the functor template call f() should be compiled and executed.Returns:Boolean value returned by f() if the static predicate Pred::value is true. Otherwise, trivially return else_.

Header <<ulink url="../../../../boost/contract/check.hpp">boost/contract/check.hpp</ulink>>RAII object that checks contracts. namespace boost { namespace contract { class check; } } Class check3boost::contract::checkRAII object that checks the contracts. // In header: <boost/contract/check.hpp> class check { public: // construct/copy/destruct template<typename F> check(F const &); check(check const &); template<typename VirtualResult> check(specify_precondition_old_postcondition_except< VirtualResult > const &); template<typename VirtualResult> check(specify_old_postcondition_except< VirtualResult > const &); template<typename VirtualResult> check(specify_postcondition_except< VirtualResult > const &); check(specify_except const &); check(specify_nothing const &); ~check(); };DescriptionIn general, when this object is constructed it checks class invariants at entry, preconditions, and makes old value copies at body. When it is destructed, it checks class invariants at exist, postconditions, and exception guarantees. This object enforces the following (see Contract Programming Overview): Postconditions are checked only if the body does not throw an exception. Exceptions guarantees are checked only if the body throws an exception. Constructor entry never checks class invariants. Destructor exit checks class invariants only if the body throws an exception (even if destructors should usually not be programmed to throw exceptions in C++ and they are implicitly declared noexcept since C++11). Static invariants are always checked at entry and exit (and regardless of the body throwing exceptions or not). When used this way, this object is constructed and initialized to the return value of one of the contract functions boost::contract::function, boost::contract::constructor, boost::contract::destructor, or boost::contract::public_function. In addition to that, this object can be constructed from a nullary functor when it is used to program implementation checks.See Also: Tutorial, Implementation Checks <anchor id="boost.contract.checkconstruct-copy-destruct"/><computeroutput>check</computeroutput> public construct/copy/destructtemplate<typename F> check(F const & f);Construct this object for implementation checks. This can be used to program checks within implementation code (body, etc.). This constructor is not declared explicit so initializations can use assignment syntax =.Throws: This can throw in case programmers specify contract failure handlers that throw exceptions instead of terminating the program (see Throw on Failure). Parameters:fNullary functor that asserts implementation checks. f() will be called as soon as this object is constructed at the point it is declared within the implementation code (see Implementation Checks). check(check const & other);Construct this object copying it from the specified one. This object will check the contract, the copied-from object will not (i.e., contract check ownership is transferred from the copied object to the new object being created by this constructor). Parameters:otherCopied-from object. template<typename VirtualResult> check(specify_precondition_old_postcondition_except< VirtualResult > const & contract);Construct this object to check the specified contract. This checks class invariants at entry (if those were specified for the given contract). This constructor is not declared explicit so initializations can use assignment syntax =.Throws: This can throw in case programmers specify contract failure handlers that throw exceptions instead of terminating the program (see Throw on Failure). Parameters:contractContract to be checked (usually the return value of boost::contract::function or boost::contract::public_function).Template Parameters:VirtualResultReturn type of the enclosing function declaring the contract if that is either a virtual or an overriding public function, otherwise this is always void. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) template<typename VirtualResult> check(specify_old_postcondition_except< VirtualResult > const & contract);Construct this object to check the specified contract. This checks class invariants at entry and preconditions (if any of those were specified for the given contract). This constructor is not declared explicit so initializations can use assignment syntax =.Throws: This can throw in case programmers specify contract failure handlers that throw exceptions instead of terminating the program (see Throw on Failure). Parameters:contractContract to be checked (usually the return value of boost::contract::function, boost::contract::constructor, boost::contract::destructor, or boost::contract::public_function).Template Parameters:VirtualResultReturn type of the enclosing function declaring the contract if that is either a virtual or an overriding public function, otherwise this is always void. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) template<typename VirtualResult> check(specify_postcondition_except< VirtualResult > const & contract);Construct this object to check the specified contract. This checks class invariants at entry and preconditions then it makes old value copies at body (if any of those were specified for the given contract). This constructor is not declared explicit so initializations can use assignment syntax =.Throws: This can throw in case programmers specify contract failure handlers that throw exceptions instead of terminating te program (see Throw on Failure). Parameters:contractContract to be checked (usually the return value of boost::contract::function, boost::contract::constructor, boost::contract::destructor, or boost::contract::public_function).Template Parameters:VirtualResultReturn type of the enclosing function declaring the contract if that is either a virtual or an overriding public function, otherwise this is always void. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) check(specify_except const & contract);Construct this object to check the specified contract. This checks class invariants at entry and preconditions then it makes old value copies at body, plus the destructor of this object will also check postconditions in this case (if any of those were specified for the given contract). This constructor is not declared explicit so initializations can use assignment syntax =.Throws: This can throw in case programmers specify contract failure handlers that throw exceptions instead of terminating the program (see Throw on Failure). Parameters:contractContract to be checked (usually the return value of boost::contract::function, boost::contract::constructor, boost::contract::destructor, or boost::contract::public_function).check(specify_nothing const & contract);Construct this object to check the specified contract. This checks class invariants at entry and preconditions then it makes old value copies at body, plus the destructor of this object will also check postconditions and exception guarantees in this case (if any of those were specified for the given contract). This constructor is not declared explicit so initializations can use assignment syntax =.Throws: This can throw in case programmers specify contract failure handlers that throw exceptions instead of terminating the program (see Throw on Failure). Parameters:contractContract to be checked (usually the return value of boost::contract::function, boost::contract::constructor, boost::contract::destructor, or boost::contract::public_function).~check();Destruct this object. This checks class invariants at exit and either postconditions when the enclosing function body did not throw an exception, or exception guarantees when the function body threw an exception (if class invariants, postconditions, and exception guarantees respectively were specified for the enclosing class and the contract parameter given when constructing this object).Throws: This can throw in case programmers specify contract failure handlers that throw exceptions instead of terminating the program (see Throw on Failure). (This is declared noexcept(false) since C++11.)

Header <<ulink url="../../../../boost/contract/constructor.hpp">boost/contract/constructor.hpp</ulink>>Program contracts for constructors. namespace boost { namespace contract { template<typename Class> specify_old_postcondition_except constructor(Class *); } } Function template constructor3boost::contract::constructorProgram contracts for constructors. // In header: <boost/contract/constructor.hpp> template<typename Class> specify_old_postcondition_except constructor(Class * obj);DescriptionThis is used to specify postconditions, exception guarantees, old value copies at body, and check class invariants for constructors (see boost::contract::constructor_precondition to specify preconditions for constructors):class u { friend class boost::contract:access; void invariant() const { // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... } public: u(...) { boost::contract::old_ptr<old_type> old_var; boost::contract::check c = boost::contract::constructor(this) // No `.precondition` (use `constructor_precondition` instead). .old([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) .postcondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .except([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; ... // Constructor body. } ... }; For optimization, this can be omitted for constructors that do not have postconditions and exception guarantees, within classes that have no invariants.See Also: Constructors Parameters:objThe object this from the scope of the enclosing constructor declaring the contract. (Constructors check all class invariants, including static and volatile invariants, see Class Invariants and Volatile Public Functions).Template Parameters:ClassThe type of the class containing the constructor declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.)Returns:The result of this function must be assigned to a variable of type boost::contract::check declared explicitly (i.e., without using C++11 auto declarations) and locally just before the code of the constructor body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL).

Header <<ulink url="../../../../boost/contract/core/access.hpp">boost/contract/core/access.hpp</ulink>>Allow to declare invariants, base types, etc all as private members. namespace boost { namespace contract { class access; } } Class access3boost::contract::accessDeclare this class as friend to program invariants and base types as private members. // In header: <boost/contract/core/access.hpp> class access { };DescriptionDeclare this class a friend of the user-defined class specifying the contracts and then invariant functions and the base types typedef can be declared as non-public members:class u #define BASES public b, private w : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; // Private. #undef BASES void invariant() const { ... } // Private (same for static and volatile). public: ... }; In real code, programmers will likely chose to declare this class as friend so to fully control public interfaces of their user-defined classes (this is not extensively done in the examples of this documentation only for brevity). This class is not intended to be directly used by programmers a part from being declared as friend (and that is why this class does not have any public member and it is not copyable).Not declaring this class friend of user-defined classes will cause compiler errors on some compilers (e.g., MSVC) because the private members needed to check the contracts will not be accessible. On other compilers (e.g., GCC and CLang), the private access will instead fail SFINAE and no compiler error will be reported while invariants and subcontracting will be silently skipped at run-time. Therefore, programmers must make sure to either declare this class as friend or to always declare invariant functions and base types typedef as public members. See Also: Access Specifiers

Header <<ulink url="../../../../boost/contract/core/check_macro.hpp">boost/contract/core/check_macro.hpp</ulink>>Macros for implementation checks. BOOST_CONTRACT_CHECK(cond) BOOST_CONTRACT_CHECK_AUDIT(cond) BOOST_CONTRACT_CHECK_AXIOM(cond) Macro BOOST_CONTRACT_CHECK3BOOST_CONTRACT_CHECKPreferred way to assert implementation check conditions. // In header: <boost/contract/core/check_macro.hpp> BOOST_CONTRACT_CHECK(cond)DescriptionIt is preferred to use this macro instead of programming implementation checks in a nullary functor passed to boost::contract::check constructor because this macro will completely remove implementation checks from the code when BOOST_CONTRACT_NO_CHECKS is defined:void f() { ... BOOST_CONTRACT_CHECK(cond); ... } BOOST_CONTRACT_CHECK, BOOST_CONTRACT_CHECK_AUDIT, and BOOST_CONTRACT_CHECK_AXIOM are the three assertion levels predefined by this library for implementation checks.See Also: Implementation Checks Parameters:condBoolean condition to check within implementation code (function body, etc.). (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and BOOST_CONTRACT_CHECK((cond)) will always work.) Macro BOOST_CONTRACT_CHECK_AUDIT3BOOST_CONTRACT_CHECK_AUDITPreferred way to assert implementation check conditions that are computationally expensive, at least compared to the computational cost of executing the function body. // In header: <boost/contract/core/check_macro.hpp> BOOST_CONTRACT_CHECK_AUDIT(cond)DescriptionThe specified condition will always be compiled and validated syntactically, but it will not be checked at run-time unless BOOST_CONTRACT_AUDITS is defined (undefined by default). This macro is defined by code equivalent to:#ifdef BOOST_CONTRACT_AUDITS #define BOOST_CONTRACT_CHECK_AUDIT(cond) \ BOOST_CONTRACT_CHECK(cond) #else #define BOOST_CONTRACT_CHECK_AUDIT(cond) \ BOOST_CONTRACT_CHECK(true || cond) #endif BOOST_CONTRACT_CHECK, BOOST_CONTRACT_CHECK_AUDIT, and BOOST_CONTRACT_CHECK_AXIOM are the three assertion levels predefined by this library for implementation checks. If there is a need, programmers are free to implement their own assertion levels defining macros similar to the one above.See Also: Assertion Levels Parameters:condBoolean condition to check within implementation code (function body, etc.). (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and BOOST_CONTRACT_CHECK_AUDIT((cond)) will always work.) Macro BOOST_CONTRACT_CHECK_AXIOM3BOOST_CONTRACT_CHECK_AXIOMPreferred way to document in the code implementation check conditions that are computationally prohibitive, at least compared to the computational cost of executing the function body. // In header: <boost/contract/core/check_macro.hpp> BOOST_CONTRACT_CHECK_AXIOM(cond)DescriptionThe specified condition will always be compiled and validated syntactically, but it will never be checked at run-time. This macro is defined by code equivalent to:#define BOOST_CONTRACT_CHECK_AXIOM(cond) \ BOOST_CONTRACT_CHECK(true || cond) BOOST_CONTRACT_CHECK, BOOST_CONTRACT_CHECK_AUDIT, and BOOST_CONTRACT_CHECK_AXIOM are the three assertion levels predefined by this library for implementation checks. If there is a need, programmers are free to implement their own assertion levels defining macros similar to the one above.See Also: Assertion Levels Parameters:condBoolean condition to check within implementation code (function body, etc.). (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and BOOST_CONTRACT_CHECK_AXIOM((cond)) will always work.)

Header <<ulink url="../../../../boost/contract/core/config.hpp">boost/contract/core/config.hpp</ulink>>Configure this library compile-time and run-time behaviours. BOOST_CONTRACT_DYN_LINK BOOST_CONTRACT_STATIC_LINK BOOST_CONTRACT_HEADER_ONLY BOOST_CONTRACT_DISABLE_THREADS BOOST_CONTRACT_MAX_ARGS BOOST_CONTRACT_BASES_TYPEDEF BOOST_CONTRACT_INVARIANT_FUNC BOOST_CONTRACT_STATIC_INVARIANT_FUNC BOOST_CONTRACT_PERMISSIVE BOOST_CONTRACT_ON_MISSING_CHECK_DECL BOOST_CONTRACT_PRECONDITIONS_DISABLE_NO_ASSERTION BOOST_CONTRACT_ALL_DISABLE_NO_ASSERTION BOOST_CONTRACT_AUDITS BOOST_CONTRACT_NO_CHECKS BOOST_CONTRACT_NO_PRECONDITIONS BOOST_CONTRACT_NO_POSTCONDITIONS BOOST_CONTRACT_NO_EXCEPTS BOOST_CONTRACT_NO_ENTRY_INVARIANTS BOOST_CONTRACT_NO_EXIT_INVARIANTS BOOST_CONTRACT_NO_INVARIANTS BOOST_CONTRACT_NO_OLDS BOOST_CONTRACT_NO_CONSTRUCTORS BOOST_CONTRACT_NO_DESTRUCTORS BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS BOOST_CONTRACT_NO_FUNCTIONS BOOST_CONTRACT_NO_CONDITIONS BOOST_CONTRACT_NO_ALL Macro BOOST_CONTRACT_DYN_LINK3BOOST_CONTRACT_DYN_LINKDefine this macro to compile this library as a shared library (recommended). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_DYN_LINKDescriptionIf this macro is defined, this library is compiled so it can be linked as a shared library (a.k.a., Dynamically Linked Library or DLL) to user code. This library will automatically define this macro when Boost libraries are built as shared libraries (e.g., defining BOOST_ALL_DYN_LINK or using bjam link=shared ...).In general this library will correctly check contracts at run-time only when compiled as a shared library, unless user code checks contracts in a single program unit (e.g., a single program with only statically linked libraries). Therefore, it is recommended to build and use this library as a shared library by defining this macro (or equivalently by building all Boost libraries as shared libraries). See Also: Getting Started Macro BOOST_CONTRACT_STATIC_LINK3BOOST_CONTRACT_STATIC_LINKDefine this macro to compile this library as a static library (not recommended). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_STATIC_LINKDescriptionIf this macro is defined, this library is compiled so it can be linked statically to user code. This library will automatically define this macro when Boost libraries are built as static libraries.This library is not guaranteed to always work correctly at run-time when this macro is defined (define BOOST_CONTRACT_DYN_LINK or BOOST_ALL_DYN_LINK instead). However, this macro can be defined and this library can be safely used as a static library for user code that checks contracts in a single program unit (e.g., a single program with only statically linked libraries). See Also: Getting Started Macro BOOST_CONTRACT_HEADER_ONLY3BOOST_CONTRACT_HEADER_ONLYAutomatically defined by this library when it is being used as a header-only library (not recommended). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_HEADER_ONLYDescriptionThis macro is not a configuration macro and this library will generate a compile-time error if users try to define it directly. This library will automatically define this macro when users do not define BOOST_CONTRACT_DYN_LINK (or BOOST_ALL_DYN_LINK) and BOOST_CONTRACT_STATIC_LINK. When used as a header-only library, this library code does not have to be compiled separately from user code, this library headers are simply included and compiled as part of the user program.This library is not guaranteed to always work correctly at run-time when this macro is defined (define BOOST_CONTRACT_DYN_LINK or BOOST_ALL_DYN_LINK instead). However, this macro can be defined and this library can be safely used as a header-only library for user code that checks contracts in a single program unit (e.g., a single program with only statically linked libraries). See Also: Getting Started Macro BOOST_CONTRACT_DISABLE_THREADS3BOOST_CONTRACT_DISABLE_THREADSDefine this macro to not lock internal library data for thread safety (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_DISABLE_THREADSDescriptionDefining this macro will make the library implementation code not thread safe so this macro should not be defined unless the library is being used by single-threaded applications only. This library will automatically define this macro when Boost libraries are built without threads (e.g., defining BOOST_DISABLE_THREADS).When this macro is left undefined this library needs to internally use some sort of global lock (to ensure contract checking is globally disabled when other contracts are being checked and also to safely access failure handler functors). That could introduce an undesired amount of synchronization in some multi-threaded applications. See Also: Assertions Macro BOOST_CONTRACT_MAX_ARGS3BOOST_CONTRACT_MAX_ARGSMaximum number of arguments for public function overrides on compilers that do not support variadic templates (default to 10). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_MAX_ARGSDescriptionOn compilers that do not support C++11 variadic templates, this macro is defined to the maximum number of arguments that public function overrides can have and pass to boost::contract::public_function (users can redefine this macro to a different value). On compilers that support variadic templates, this macro has no effect.Regardless of the value of this macro and of compiler support for variadic templates, there might be an intrinsic limit of about 18 arguments for public function overrides (because of similar limits in Boost.MPL and Boost.FunctionTypes internally used by this library). See Also: No Macros Macro BOOST_CONTRACT_BASES_TYPEDEF3BOOST_CONTRACT_BASES_TYPEDEFDefine the name of the base type typedef (base_types by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_BASES_TYPEDEFDescriptionThis macro expands to the name of the typedef that lists the base classes for subcontracting via BOOST_CONTRACT_BASE_TYPES:class u #define BASES public b, private w : BASES { friend class boost::contract:access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) BOOST_CONTRACT_TYPEDEF; #undef BASES ... }; When used this way, users can redefine this macro if the typedef must have a name different from base_types (because of name clashes in user code, etc.).See Also: Base Classes Macro BOOST_CONTRACT_INVARIANT_FUNC3BOOST_CONTRACT_INVARIANT_FUNCDefine the name of the class invariant member function (invariant by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_INVARIANT_FUNCDescriptionThis macro expands to the name of the const and const volatile member functions that check class invariants and volatile class invariants respectively:class u { friend class boost::contract::access; void BOOST_CONTRACT_INVARIANT_FUNC() const { BOOST_CONTRACT_ASSERT(...); ... } void BOOST_CONTRACT_INVARIANT_FUNC() const volatile { BOOST_CONTRACT_ASSERT(...); ... } ... }; When used this way, users can redefine this macro if the invariant functions must have a name different from invariant (because of name clashes in user code, etc.).C++ does not allow to overload member functions based on the static classifier, so this macro must always be defined to be different than the function name defined for BOOST_CONTRACT_STATIC_INVARIANT_FUNC. See Also: Class Invariants, Volatile Public Functions Macro BOOST_CONTRACT_STATIC_INVARIANT_FUNC3BOOST_CONTRACT_STATIC_INVARIANT_FUNCDefine the name of the static invariant member function (static_invariant by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_STATIC_INVARIANT_FUNCDescriptionThis macro expands to the name of the static member function that checks static class invariants:class u { friend class boost::contract::access; static void BOOST_CONTRACT_STATIC_INVARIANT_FUNC() { BOOST_CONTRACT_ASSERT(...); ... } ... }; When used this way, users can redefine this macro if the static invariant function must have a name different from static_invariant (because of name clashes in user code, etc.).C++ does not allow to overload member functions based on the static classifier, so this macro must always be defined to be different than the function name defined for BOOST_CONTRACT_INVARIANT_FUNC. See Also: Class Invariants Macro BOOST_CONTRACT_PERMISSIVE3BOOST_CONTRACT_PERMISSIVEDisable some compile-time errors generated by this library (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_PERMISSIVEDescriptionDefining this macro disables a number of static checks and related compile-time errors generated by this library, for example: The static invariant member function named as BOOST_CONTRACT_STATIC_INVARIANT_FUNC must be declared static. Non-static invariant member functions named as BOOST_CONTRACT_INVARIANT_FUNC must be declared either const, const volatile, or volatile const. Derived classes that program contracts for one or more public function overrides via boost::contract::public_function must also define the BOOST_CONTRACT_BASE_TYPES typedef. In general, it is not recommended to define this macro because these compile-time checks can guard against misuses of this library.See Also: Class Invariants, Base Classes Macro BOOST_CONTRACT_ON_MISSING_CHECK_DECL3BOOST_CONTRACT_ON_MISSING_CHECK_DECLCode block to execute if contracts are not assigned to a boost::contract::check variable (undefined and executes BOOST_ASSERT(false) by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_ON_MISSING_CHECK_DECLDescriptionIn general, there is a logic error in the program when contracts are not explicitly assigned to a local variable of type boost::contract::check and without using C++11 auto declarations (because that is a misuse of this library). Therefore, by default (i.e., when this macro is not defined) this library calls BOOST_ASSERT(false) in those cases. If this macro is defined, this library will execute the code expanded by this macro instead of calling BOOST_ASSERT(false) (if programmers prefer to throw an exception, etc.).This macro can also be defined to be any block of code (and use empty curly brackets {} to generate no error, not recommended), for example (on GCC): gcc -DBOOST_CONTRACT_ON_MISSING_CHECK_DECL='{ throw std::logic_error("missing contract check declaration"); }' ... See Also: Tutorial Macro BOOST_CONTRACT_PRECONDITIONS_DISABLE_NO_ASSERTION3BOOST_CONTRACT_PRECONDITIONS_DISABLE_NO_ASSERTIONDefine this macro to not disable other assertions while checking preconditions (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_PRECONDITIONS_DISABLE_NO_ASSERTIONDescriptionNot disabling other assertions while checking preconditions can lead to infinite recursion in user code so by default this macro is not defined.However, the [N1962] proposal does not disable assertions while checking preconditions because arguments can reach the function body unchecked if assertions are disabled while checking preconditions (e.g., when these same functions bodies are called to check the preconditions in question). This macro can be defined to obtain the behaviour specified in [N1962] (at the risk of infinite recursion).See Also: Feature Summary Macro BOOST_CONTRACT_ALL_DISABLE_NO_ASSERTION3BOOST_CONTRACT_ALL_DISABLE_NO_ASSERTIONDefine this macro to not disable any assertion while checking other assertions (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_ALL_DISABLE_NO_ASSERTIONDescriptionNot disabling assertions while checking other assertions can lead to infinite recursion in user code so by default this macro is not defined. (Defining this macro automatically implies that other assertion checking is disabled while checking preconditions as if BOOST_CONTRACT_PRECONDITIONS_DISABLE_NO_ASSERTION was also defined.)See Also: Feature Summary Macro BOOST_CONTRACT_AUDITS3BOOST_CONTRACT_AUDITSDefine this macro to evaluate and check audit assertions at run-time (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_AUDITSDescriptionAudit assertions and implementation checks programmed via BOOST_CONTRACT_ASSERT_AUDIT and BOOST_CONTRACT_CHECK_AUDIT are always compiled and validated syntactically. However, they are not evaluated and checked at run-time unless this macro is defined (because these conditions can be computationally expensive, at least compared to the computational cost of executing the function body).See Also: Assertion Levels Macro BOOST_CONTRACT_NO_CHECKS3BOOST_CONTRACT_NO_CHECKSIf defined, this library disables implementation checks (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_CHECKSDescriptionIf this macro is defined, this library internal code is also optimized to reduce compile-time (not just run-time) overhead associated with implementation checks. In addition, users can manually program #ifndef statements in their code using this macro to completely disable compilation of implementation checks or use BOOST_CONTRACT_CHECK (recommended).See Also: Implementation Checks, Disable Contract Checking, Disable Contract Compilation Macro BOOST_CONTRACT_NO_PRECONDITIONS3BOOST_CONTRACT_NO_PRECONDITIONSIf defined, this library does not check preconditions (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_PRECONDITIONSDescriptionIf this macro is defined, this library internal code is also optimized to reduce compile-time (not just run-time) overhead associated with checking preconditions. In addition, users can manually program #ifndef statements in their code using this macro to completely disable compilation of preconditions or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).See Also: Preconditions, Disable Contract Checking, Disable Contract Compilation Macro BOOST_CONTRACT_NO_POSTCONDITIONS3BOOST_CONTRACT_NO_POSTCONDITIONSIf defined, this library does not check postconditions (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_POSTCONDITIONSDescriptionIf this macro is defined, this library internal code is also optimized to reduce compile-time (not just run-time) overhead associated with checking postconditions. In addition, users can manually program #ifndef statements in their code using this macro to completely disable compilation of postconditions or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).It is necessary to disable both postconditions and exception guarantees defining BOOST_CONTRACT_NO_POSTCONDITIONS and BOOST_CONTRACT_NO_EXCEPTS in order to disable old value copies (see BOOST_CONTRACT_NO_OLDS).See Also: Postconditions, Disable Contract Checking, Disable Contract Compilation Macro BOOST_CONTRACT_NO_EXCEPTS3BOOST_CONTRACT_NO_EXCEPTSIf defined, this library does not check exception guarantees (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_EXCEPTSDescriptionIf this macro is defined, this library internal code is also optimized to reduce compile-time (not just run-time) overhead associated with checking exception guarantees. In addition, users can manually program #ifndef statements in their code using this macro to completely disable compilation of exception guarantees or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).It is necessary to disable both postconditions and exception guarantees defining BOOST_CONTRACT_NO_POSTCONDITIONS and BOOST_CONTRACT_NO_EXCEPTS in order to disable old value copies (see BOOST_CONTRACT_NO_OLDS).See Also: Exception Guarantees, Disable Contract Checking, Disable Contract Compilation Macro BOOST_CONTRACT_NO_ENTRY_INVARIANTS3BOOST_CONTRACT_NO_ENTRY_INVARIANTSIf defined, this library does not check class invariants at entry (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_ENTRY_INVARIANTSDescriptionIf this macro is defined, this library internal code is also optimized to reduce compile-time (not just run-time) overhead associated with checking class invariants at entry. In addition, users can manually program #ifndef statements in their code using this macro to completely disable compilation of entry class invariants or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).This macro is automatically defined when BOOST_CONTRACT_NO_INVARIANTS is defined.See Also: Class Invariants, Disable Contract Checking, Disable Contract Compilation Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS3BOOST_CONTRACT_NO_EXIT_INVARIANTSIf defined, this library does not check class invariants at exit (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_EXIT_INVARIANTSDescriptionIf this macro is defined, this library internal code is also optimized to reduce compile-time (not just run-time) overhead associated with checking class invariants at exit. In addition, users can manually program #ifndef statements in their code using this macro to completely disable compilation of exit class invariants or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).This macro is automatically defined when BOOST_CONTRACT_NO_INVARIANTS is defined.See Also: Class Invariants, Disable Contract Checking, Disable Contract Compilation Macro BOOST_CONTRACT_NO_INVARIANTS3BOOST_CONTRACT_NO_INVARIANTSIf defined, this library does not check class invariants (undefined by default). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_INVARIANTSDescriptionIf this macro is defined, this library internal code is also optimized to reduce compile-time (not just run-time) overhead associated with checking class invariants. In addition, users can manually program #ifndef statements in their code using this macro to completely disable compilation of class invariants or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).Defining this macro is equivalent to defining both BOOST_CONTRACT_NO_ENTRY_INVARIANTS and BOOST_CONTRACT_NO_EXIT_INVARIANTS.See Also: Class Invariants, Disable Contract Checking, Disable Contract Compilation Macro BOOST_CONTRACT_NO_OLDS3BOOST_CONTRACT_NO_OLDSAutomatically defined by this library when old value copies are not to be performed. // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_OLDSDescriptionThis macro is not a configuration macro and this library will generate a compile-time error if users try to define it directly. This library will automatically define this macro when users define both BOOST_CONTRACT_NO_POSTCONDITIONS and BOOST_CONTRACT_NO_EXCEPTS. Users can manually program #ifndef statements in their code using this macro to completely disable compilation of old value copies or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).See Also: Old Values, Old Values Copied at Body, Disable Contract Compilation Macro BOOST_CONTRACT_NO_CONSTRUCTORS3BOOST_CONTRACT_NO_CONSTRUCTORSAutomatically defined by this library when contracts are not checked for constructors. // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_CONSTRUCTORSDescriptionThis macro is not a configuration macro and this library will generate a compile-time error if users try to define it directly. This library will automatically define this macro when users define all BOOST_CONTRACT_NO_INVARIANTS, BOOST_CONTRACT_NO_POSTCONDITIONS, and BOOST_CONTRACT_NO_EXCEPTS. Users can manually program #ifndef statements in their code using this macro to completely disable compilation of contracts for constructors or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).Constructor preconditions are checked separately by boost::contract::constructor_precondition so they are disabled by BOOST_CONTRACT_NO_PRECONDITIONS instead. See Also: Constructors, Disable Contract Compilation Macro BOOST_CONTRACT_NO_DESTRUCTORS3BOOST_CONTRACT_NO_DESTRUCTORSAutomatically defined by this library when contracts are not checked for destructors. // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_DESTRUCTORSDescriptionThis macro is not a configuration macro and this library will generate a compile-time error if users try to define it directly. This library will automatically define this macro when users define all BOOST_CONTRACT_NO_INVARIANTS, BOOST_CONTRACT_NO_POSTCONDITIONS, and BOOST_CONTRACT_NO_EXCEPTS. Users can manually program #ifndef statements in their code using this macro to completely disable compilation of contracts for destructors or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).See Also: Destructors, Disable Contract Compilation Macro BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS3BOOST_CONTRACT_NO_PUBLIC_FUNCTIONSAutomatically defined by this library when contracts are not checked for public functions. // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_PUBLIC_FUNCTIONSDescriptionThis macro is not a configuration macro and this library will generate a compile-time error if users try to define it directly. This library will automatically define this macro when users define all BOOST_CONTRACT_NO_INVARIANTS, BOOST_CONTRACT_NO_PRECONDITIONS, BOOST_CONTRACT_NO_POSTCONDITIONS, and BOOST_CONTRACT_NO_EXCEPTS. Users can manually program #ifndef statements in their code using this macro to completely disable compilation of contracts for public functions or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).See Also: Public Functions, Disable Contract Compilation Macro BOOST_CONTRACT_NO_FUNCTIONS3BOOST_CONTRACT_NO_FUNCTIONSAutomatically defined by this library when contracts are not checked for non-member, private, or protected functions. // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_FUNCTIONSDescriptionThis macro is not a configuration macro and this library will generate a compile-time error if users try to define it directly. This library will automatically define this macro when users define all BOOST_CONTRACT_NO_PRECONDITIONS, BOOST_CONTRACT_NO_POSTCONDITIONS, and BOOST_CONTRACT_NO_EXCEPTS. Users can manually program #ifndef statements in their code using this macro to completely disable compilation of contracts for non-member, private and protected functions, or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).This macro is also used when contracts are not checked for private or protected functions, lambda functions, code blocks, loops, etc.See Also: Non-Member Functions, Private and Protected Functions, Lambdas, Loops, Code Blocks, Disable Contract Compilation Macro BOOST_CONTRACT_NO_CONDITIONS3BOOST_CONTRACT_NO_CONDITIONSAutomatically defined by this library when contracts are not checked for preconditions, postconditions, exceptions guarantees, and class invariants (excluding implementation checks). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_CONDITIONSDescriptionThis macro is not a configuration macro and this library will generate a compile-time error if users try to define it directly. This library will automatically define this macro when users define all BOOST_CONTRACT_NO_PRECONDITIONS, BOOST_CONTRACT_NO_POSTCONDITIONS, BOOST_CONTRACT_NO_EXCEPTS, and BOOST_CONTRACT_NO_INVARIANTS. Users can manually program #ifndef statements in their code using this macro to completely disable compilation of contracts within specifications (so excluding implementation checks which are contracts within implementations instead), or use the macros defined in boost/contract_macro.hpp (recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).See Also: Disable Contract Compilation Macro BOOST_CONTRACT_NO_ALL3BOOST_CONTRACT_NO_ALLAutomatically defined by this library when contracts are not checked at all (neither for specifications nor for implementations). // In header: <boost/contract/core/config.hpp> BOOST_CONTRACT_NO_ALLDescriptionThis macro is not a configuration macro and this library will generate a compile-time error if users try to define it directly. This library will automatically define this macro when users define all BOOST_CONTRACT_NO_INVARIANTS, BOOST_CONTRACT_NO_PRECONDITIONS, BOOST_CONTRACT_NO_POSTCONDITIONS, BOOST_CONTRACT_NO_EXCEPTS, and BOOST_CONTRACT_NO_CHECKS. For example, users can manually program #ifndef statements in their code using this macro to avoid including the boost/contract.hpp header all together:#include <boost/contract/core/config.hpp> #ifndef BOOST_CONTRACT_NO_ALL #include <boost/contract.hpp> #endif Or, use the boost/contract_macro.hpp header and related macros instead (because the boost/contract_macro.hpp header is already optimized to not include other headers from this library when contracts are not checked, but recommended only for applications where it is truly necessary to completely remove contract code compilation from production code).See Also: Disable Contract Compilation

Header <<ulink url="../../../../boost/contract/core/constructor_precondition.hpp">boost/contract/core/constructor_precondition.hpp</ulink>>Program preconditions for constructors. namespace boost { namespace contract { template<typename Class> class constructor_precondition; } } Class template constructor_precondition3boost::contract::constructor_preconditionProgram preconditions for constructors. // In header: <boost/contract/core/constructor_precondition.hpp> template<typename Class> class constructor_precondition { public: // construct/copy/destruct constructor_precondition(); template<typename F> explicit constructor_precondition(F const &); };DescriptionThis class must be the very first base of the class declaring the constructor for which preconditions are programmed (that way constructor arguments can be checked by preconditions even before they are used to initialize other base classes):class u #define BASES private boost::contract::constructor_precondition, \ public b : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES public: explicit u(unsigned x) : boost::contract::constructor_precondition([&] { BOOST_CONTRACT_ASSERT(x != 0); ... }), b(1.0 / float(x)) { ... } ... }; User-defined classes should inherit privately from this class (to not alter the public interface of user-defined classes). In addition, this class should never be declared as a virtual base (because virtual bases are initialized only once across the entire inheritance hierarchy preventing preconditions of other base classes from being checked).This class cannot be used this way in a union because unions cannot have base classes in C++. Instead, this class is used in a union to declare a local object within the constructor definition just before boost::contract::constructor is used (see Unions).See Also: Constructors Template Parameterstypename ClassThe class type of the constructor for which preconditions are being programmed. <anchor id="boost.contract.constructor_preconditionconstruct-copy-destruct"/><computeroutput>constructor_precondition</computeroutput> public construct/copy/destructconstructor_precondition();Construct this object without specifying constructor preconditions. This is implicitly called for those constructors of the contracted class that do not specify preconditions.The implementation of this library is optimized so that calling this default constructor should amount to negligible compile-time and run-time overheads (likely to be optimized away completely by most compilers). template<typename F> explicit constructor_precondition(F const & f);Construct this object specifying constructor preconditions. Parameters:fNullary functor called by this library to check constructor preconditions f(). Assertions within this functor call are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract failure (and will result in this library calling boost::contract::precondition_failure). This functor should capture variables by (constant) value, or better by (constant) reference to avoid extra copies.

Header <<ulink url="../../../../boost/contract/core/exception.hpp">boost/contract/core/exception.hpp</ulink>>Handle contract assertion failures. namespace boost { namespace contract { class assertion_failure; class bad_virtual_result_cast; class exception; enum from; typedef boost::function< void(from)> from_failure_handler; typedef boost::function< void()> failure_handler; failure_handler const & set_check_failure(failure_handler const &); failure_handler get_check_failure(); void check_failure(); from_failure_handler const & set_precondition_failure(from_failure_handler const &); from_failure_handler get_precondition_failure(); void precondition_failure(from); from_failure_handler const & set_postcondition_failure(from_failure_handler const &); from_failure_handler get_postcondition_failure(); void postcondition_failure(from); from_failure_handler const & set_except_failure(from_failure_handler const &); from_failure_handler get_except_failure(); void except_failure(from); from_failure_handler const & set_old_failure(from_failure_handler const &); from_failure_handler get_old_failure(); void old_failure(from); from_failure_handler const & set_entry_invariant_failure(from_failure_handler const &); from_failure_handler get_entry_invariant_failure(); void entry_invariant_failure(from); from_failure_handler const & set_exit_invariant_failure(from_failure_handler const &); from_failure_handler get_exit_invariant_failure(); void exit_invariant_failure(from); from_failure_handler const & set_invariant_failure(from_failure_handler const &); } } Class assertion_failure3boost::contract::assertion_failureException typically used to report a contract assertion failure. // In header: <boost/contract/core/exception.hpp> class assertion_failure : public std::exception, public boost::contract::exception { public: // construct/copy/destruct explicit assertion_failure(char const * = "", unsigned long = 0, char const * = ""); explicit assertion_failure(char const *); ~assertion_failure(); // public member functions virtual char const * what() const; char const * file() const; unsigned long line() const; char const * code() const; };DescriptionThis exception is thrown by code expanded by BOOST_CONTRACT_ASSERT (but it can also be thrown by user code programmed manually without that macro). This exception is typically used to report contract assertion failures because it contains detailed information about the file name, line number, and source code of the asserted condition (so it can be used by this library to provide detailed error messages when handling contract assertion failures).However, any other exception can be used to report a contract assertion failure (including user-defined exceptions). This library will call the appropriate contract failure handler function ( boost::contract::precondition_failure, etc.) when this or any other exception is thrown while checking contracts (by default, these failure handler functions print an error message to std::cerr and terminate the program, but they can be customized to take any other action).See Also: Throw on Failure, No Macros <anchor id="boost.contract.assertion_failureconstruct-copy-destruct"/><computeroutput>assertion_failure</computeroutput> public construct/copy/destructexplicit assertion_failure(char const * file = "", unsigned long line = 0, char const * code = "");Construct this object with file name, line number, and source code text of an assertion condition (all optional). This constructor can also be used to specify no information (default constructor), or to specify only file name and line number but not source code text (because of the parameter default values). Parameters:codeText listing the source code of the assertion condition. fileName of the file containing the assertion (usually set using __FILE__). lineNumber of the line containing the assertion (usually set using __LINE__). explicit assertion_failure(char const * code);Construct this object only with the source code text of the assertion condition. Parameters:codeText listing the source code of the assertion condition. ~assertion_failure();Destruct this object. Throws: This is declared noexcept (or throw() before C++11). <anchor id="idm45394999515280-bb"/><computeroutput>assertion_failure</computeroutput> public member functionsvirtual char const * what() const;String describing the failed assertion. Throws: This is declared noexcept (or throw() before C++11). Returns:A string formatted similarly to the following: assertion "`code()`" failed: file "`file()`", line `line()` (where `` indicate execution quotes). File, line, and code will be omitted from this string if they were not specified when constructing this object. char const * file() const;Name of the file containing the assertion. Returns:File name as specified at construction (or "" if no file was specified). unsigned long line() const;Number of the line containing the assertion. Returns:Line number as specified at construction (or 0 if no line number was specified). char const * code() const;Text listing the source code of the assertion condition. Returns:Assertion condition source code as specified at construction (or "" if no source code text was specified). Class bad_virtual_result_cast3boost::contract::bad_virtual_result_castException thrown when inconsistent return values are passed to overridden virtual public functions. // In header: <boost/contract/core/exception.hpp> class bad_virtual_result_cast : public std::bad_cast, public boost::contract::exception { public: // construct/copy/destruct explicit bad_virtual_result_cast(char const *, char const *); ~bad_virtual_result_cast(); // public member functions virtual char const * what() const; };DescriptionThis exception is thrown when programmers pass to this library return value parameters for public function overrides in derived classes that are not consistent with the return type parameter passed for the virtual public function being overridden from the base classes. This allows this library to give more descriptive error messages in such cases of misuse.This exception is internally thrown by this library and programmers should not need to throw it from user code.See Also: Public Function Overrides <anchor id="boost.contract.bad_virtual_result_castconstruct-copy-destruct"/><computeroutput>bad_virtual_result_cast</computeroutput> public construct/copy/destructexplicit bad_virtual_result_cast(char const * from_type_name, char const * to_type_name);Construct this object with the name of the from- and to- result types. Parameters:from_type_nameName of the from-type (source of the cast). to_type_nameName of the to-type (destination of the cast). ~bad_virtual_result_cast();Destruct this object. Throws: This is declared noexcept (or throw() before C++11). <anchor id="idm45394999483408-bb"/><computeroutput>bad_virtual_result_cast</computeroutput> public member functionsvirtual char const * what() const;Description for this error (containing both from- and to- type names). Throws: This is declared noexcept (or throw() before C++11). Class exception3boost::contract::exceptionPublic base class for all exceptions directly thrown by this library. // In header: <boost/contract/core/exception.hpp> class exception { public: // construct/copy/destruct ~exception(); };DescriptionThis class does not inherit from std::exception because exceptions deriving from this class will do that (inheriting from std::exception, std::bad_cast, etc.).See Also: boost::contract::assertion_failure, boost::contract::bad_virtual_result_cast, etc. <anchor id="boost.contract.exceptionconstruct-copy-destruct"/><computeroutput>exception</computeroutput> public construct/copy/destruct~exception();Destruct this object. Throws: This is declared noexcept (or throw() before C++11). Type from3boost::contract::fromIndicate the kind of operation where the contract assertion failed. // In header: <boost/contract/core/exception.hpp> enum from { from_constructor, from_destructor, from_function };DescriptionThis is passed as a parameter to the assertion failure handler functions. For example, it might be necessary to know in which operation an assertion failed to make sure exceptions are never thrown from destructors, not even when contract failure handlers are programmed by users to throw exceptions instead of terminating the program.See Also: Throw on Failure from_constructorAssertion failed when checking contracts for constructors. from_destructorAssertion failed when checking contracts for destructors . from_functionAssertion failed when checking contracts for functions (members or not, public or not). Type definition from_failure_handler3from_failure_handlerType of assertion failure handler functions (with from parameter). // In header: <boost/contract/core/exception.hpp> typedef boost::function< void(from)> from_failure_handler;DescriptionAssertion failure handler functions specified by this type must be functors returning void and taking a single parameter of type boost::contract::from. For example, this is used to specify contract failure handlers for class invariants, preconditions, postconditions, and exception guarantees.See Also: Throw on Failure Type definition failure_handler3failure_handlerType of assertion failure handler functions (without from parameter). // In header: <boost/contract/core/exception.hpp> typedef boost::function< void()> failure_handler;DescriptionAssertion failure handler functions specified by this type must be nullary functors returning void. For example, this is used to specify contract failure handlers for implementation checks.See Also: Throw on Failure Function set_check_failure3boost::contract::set_check_failureSet failure handler for implementation checks. // In header: <boost/contract/core/exception.hpp> failure_handler const & set_check_failure(failure_handler const & f);DescriptionSet a new failure handler and returns it.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Implementation Checks Parameters:fNew failure handler functor to set.Returns:Same failure handler functor f passed as parameter (e.g., for concatenating function calls).Function get_check_failure3boost::contract::get_check_failureReturn failure handler currently set for implementation checks. // In header: <boost/contract/core/exception.hpp> failure_handler get_check_failure();DescriptionThis is often called only internally by this library.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Implementation Checks Returns:A copy of the failure handler currently set.Function check_failure3boost::contract::check_failureCall failure handler for implementation checks. // In header: <boost/contract/core/exception.hpp> void check_failure();DescriptionThis is often called only internally by this library.Throws: This can throw in case programmers specify a failure handler that throws exceptions on implementation check failures (not the default).See Also: Throw on Failure, Implementation Checks Function set_precondition_failure3boost::contract::set_precondition_failureSet failure handler for preconditions. // In header: <boost/contract/core/exception.hpp> from_failure_handler const & set_precondition_failure(from_failure_handler const & f);DescriptionSet a new failure handler and returns it.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Preconditions Parameters:fNew failure handler functor to set.Returns:Same failure handler functor f passed as parameter (e.g., for concatenating function calls).Function get_precondition_failure3boost::contract::get_precondition_failureReturn failure handler currently set for preconditions. // In header: <boost/contract/core/exception.hpp> from_failure_handler get_precondition_failure();DescriptionThis is often called only internally by this library.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Preconditions Returns:A copy of the failure handler currently set.Function precondition_failure3boost::contract::precondition_failureCall failure handler for preconditions. // In header: <boost/contract/core/exception.hpp> void precondition_failure(from where);DescriptionThis is often called only internally by this library.Throws: This can throw in case programmers specify a failure handler that throws exceptions on contract assertion failures (not the default). See Also: Throw on Failure, Preconditions Parameters:whereOperation that failed the contract assertion (when this function is called by this library, this parameter will never be from_destructor because destructors do not have preconditions).Function set_postcondition_failure3boost::contract::set_postcondition_failureSet failure handler for postconditions. // In header: <boost/contract/core/exception.hpp> from_failure_handler const & set_postcondition_failure(from_failure_handler const & f);DescriptionSet a new failure handler and returns it.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Postconditions Parameters:fNew failure handler functor to set.Returns:Same failure handler functor f passed as parameter (e.g., for concatenating function calls).Function get_postcondition_failure3boost::contract::get_postcondition_failureReturn failure handler currently set for postconditions. // In header: <boost/contract/core/exception.hpp> from_failure_handler get_postcondition_failure();DescriptionThis is often called only internally by this library.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Postconditions Returns:A copy of the failure handler currently set.Function postcondition_failure3boost::contract::postcondition_failureCall failure handler for postconditions. // In header: <boost/contract/core/exception.hpp> void postcondition_failure(from where);DescriptionThis is often called only internally by this library.Throws: This can throw in case programmers specify a failure handler that throws exceptions on contract assertion failures (not the default). See Also: Throw on Failure, Postconditions Parameters:whereOperation that failed the contract assertion (e.g., this might be useful to program failure handler functors that never throw from destructors, not even when they are programmed by users to throw exceptions instead of terminating the program).Function set_except_failure3boost::contract::set_except_failureSet failure handler for exception guarantees. // In header: <boost/contract/core/exception.hpp> from_failure_handler const & set_except_failure(from_failure_handler const & f);DescriptionSet a new failure handler and returns it.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Exception Guarantees Parameters:fNew failure handler functor to set.Returns:Same failure handler functor f passed as parameter (e.g., for concatenating function calls).Function get_except_failure3boost::contract::get_except_failureReturn failure handler currently set for exception guarantees. // In header: <boost/contract/core/exception.hpp> from_failure_handler get_except_failure();DescriptionThis is often called only internally by this library.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Exception Guarantees Returns:A copy of the failure handler currently set.Function except_failure3boost::contract::except_failureCall failure handler for exception guarantees. // In header: <boost/contract/core/exception.hpp> void except_failure(from where);DescriptionThis is often called only internally by this library.Throws: This can throw in case programmers specify a failure handler that throws exceptions on contract assertion failures (not the default), however:When this failure handler is called there is already an active exception (the one that caused the exception guarantees to be checked in the first place). Therefore, programming this failure handler to throw yet another exception will force C++ to automatically terminate the program. See Also: Throw on Failure, Exception Guarantees Parameters:whereOperation that failed the contract assertion.Function set_old_failure3boost::contract::set_old_failureSet failure handler for old values copied at body. // In header: <boost/contract/core/exception.hpp> from_failure_handler const & set_old_failure(from_failure_handler const & f);DescriptionSet a new failure handler and returns it.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Old Values Copied at Body Parameters:fNew failure handler functor to set.Returns:Same failure handler functor f passed as parameter (e.g., for concatenating function calls).Function get_old_failure3boost::contract::get_old_failureReturn failure handler currently set for old values copied at body. // In header: <boost/contract/core/exception.hpp> from_failure_handler get_old_failure();DescriptionThis is often called only internally by this library.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Old Values Copied at Body Returns:A copy of the failure handler currently set.Function old_failure3boost::contract::old_failureCall failure handler for old values copied at body. // In header: <boost/contract/core/exception.hpp> void old_failure(from where);DescriptionThis is often called only internally by this library.Throws: This can throw in case programmers specify a failure handler that throws exceptions on contract assertion failures (not the default). See Also: Throw on Failure, Old Values Copied at Body Parameters:whereOperation that failed the old value copy (e.g., this might be useful to program failure handler functors that never throw from destructors, not even when they are programmed by users to throw exceptions instead of terminating the program).Function set_entry_invariant_failure3boost::contract::set_entry_invariant_failureSet failure handler for class invariants at entry. // In header: <boost/contract/core/exception.hpp> from_failure_handler const & set_entry_invariant_failure(from_failure_handler const & f);DescriptionSet a new failure handler and returns it.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Class Invariants, Volatile Public Functions Parameters:fNew failure handler functor to set.Returns:Same failure handler functor f passed as parameter (e.g., for concatenating function calls).Function get_entry_invariant_failure3boost::contract::get_entry_invariant_failureReturn failure handler currently set for class invariants at entry. // In header: <boost/contract/core/exception.hpp> from_failure_handler get_entry_invariant_failure();DescriptionThis is often called only internally by this library.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Class Invariants, Volatile Public Functions Returns:A copy of the failure handler currently set.Function entry_invariant_failure3boost::contract::entry_invariant_failureCall failure handler for class invariants at entry. // In header: <boost/contract/core/exception.hpp> void entry_invariant_failure(from where);DescriptionThis is often called only internally by this library.Throws: This can throw in case programmers specify a failure handler that throws exceptions on contract assertion failures (not the default). See Also: Throw on Failure, Class Invariants, Volatile Public Functions Parameters:whereOperation that failed the contract assertion (e.g., this might be useful to program failure handler functors that never throw from destructors, not even when they are programmed by users to throw exceptions instead of terminating the program).Function set_exit_invariant_failure3boost::contract::set_exit_invariant_failureSet failure handler for class invariants at exit. // In header: <boost/contract/core/exception.hpp> from_failure_handler const & set_exit_invariant_failure(from_failure_handler const & f);DescriptionSet a new failure handler and returns it.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Class Invariants, Volatile Public Functions Parameters:fNew failure handler functor to set.Returns:Same failure handler functor f passed as parameter (e.g., for concatenating function calls).Function get_exit_invariant_failure3boost::contract::get_exit_invariant_failureReturn failure handler currently set for class invariants at exit. // In header: <boost/contract/core/exception.hpp> from_failure_handler get_exit_invariant_failure();DescriptionThis is often called only internally by this library.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Class Invariants, Volatile Public Functions Returns:A copy of the failure handler currently set.Function exit_invariant_failure3boost::contract::exit_invariant_failureCall failure handler for class invariants at exit. // In header: <boost/contract/core/exception.hpp> void exit_invariant_failure(from where);DescriptionThis is often called only internally by this library.Throws: This can throw in case programmers specify a failure handler that throws exceptions on contract assertion failures (not the default). See Also: Throw on Failure, Class Invariants, Volatile Public Functions Parameters:whereOperation that failed the contract assertion (e.g., this might be useful to program failure handler functors that never throw from destructors, not even when they are programmed by users to throw exceptions instead of terminating the program).Function set_invariant_failure3boost::contract::set_invariant_failureSet failure handler for class invariants (at both entry and exit). // In header: <boost/contract/core/exception.hpp> from_failure_handler const & set_invariant_failure(from_failure_handler const & f);DescriptionThis is provided for convenience and it is equivalent to call both boost::contract::set_entry_invariant_failure and boost::contract::set_exit_invariant_failure with the same functor parameter f.Throws: This is declared noexcept (or throw() before C++11). See Also: Throw on Failure, Class Invariants, Volatile Public Functions Parameters:fNew failure handler functor to set for both entry and exit invariants.Returns:Same failure handler functor f passed as parameter (e.g., for concatenating function calls).

Header <<ulink url="../../../../boost/contract/core/specify.hpp">boost/contract/core/specify.hpp</ulink>>Specify preconditions, old values copied at body, postconditions, and exception guarantees. Preconditions, old values copied at body, postconditions, and exception guarantees are all optionals but, when they are specified, they need to be specified in that order. namespace boost { namespace contract { class specify_except; class specify_nothing; template<typename VirtualResult = void> class specify_old_postcondition_except; template<typename VirtualResult = void> class specify_postcondition_except; template<typename VirtualResult = void> class specify_precondition_old_postcondition_except; } } Class specify_except3boost::contract::specify_exceptAllow to specify exception guarantees. // In header: <boost/contract/core/specify.hpp> class specify_except { public: // construct/copy/destruct ~specify_except(); // public member functions template<typename F> specify_nothing except(F const &); };DescriptionAllow to specify the functor this library will call to check exception guarantees. This object is internally constructed by the library when users specify contracts calling boost::contract::function and similar functions (that is why this class does not have a public constructor).See Also: Exception Guarantees <anchor id="boost.contract.specify_exceptconstruct-copy-destruct"/><computeroutput>specify_except</computeroutput> public construct/copy/destruct~specify_except();Destruct this object. Throws: This is declared noexcept(false) since C++11 to allow users to program failure handlers that throw exceptions on contract assertion failures (not the default, see Throw on Failure). <anchor id="idm45394999264384-bb"/><computeroutput>specify_except</computeroutput> public member functionstemplate<typename F> specify_nothing except(F const & f);Allow to specify exception guarantees. Parameters:fNullary functor called by this library to check exception guarantees f(). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::except_failure). This functor should capture variables by (constant) references (to access the values they will have at function exit).Returns:After exception guarantees have been specified, the object returned by this function does not allow to specify any additional contract. Class specify_nothing3boost::contract::specify_nothingUsed to prevent setting other contract conditions after exception guarantees. // In header: <boost/contract/core/specify.hpp> class specify_nothing { public: // construct/copy/destruct ~specify_nothing(); };DescriptionThis class has no member function so it is used to prevent specifying additional functors to check any other contract. This object is internally constructed by the library when users specify contracts calling boost::contract::function and similar functions (that is why this class does not have a public constructor).See Also: Tutorial <anchor id="boost.contract.specify_nothingconstruct-copy-destruct"/><computeroutput>specify_nothing</computeroutput> public construct/copy/destruct~specify_nothing();Destruct this object. Throws: This is declared noexcept(false) since C++11 to allow users to program failure handlers that throw exceptions on contract assertion failures (not the default, see Throw on Failure). Class template specify_old_postcondition_except3boost::contract::specify_old_postcondition_exceptAllow to specify old values copied at body, postconditions, and exception guarantees. // In header: <boost/contract/core/specify.hpp> template<typename VirtualResult = void> class specify_old_postcondition_except { public: // construct/copy/destruct ~specify_old_postcondition_except(); // public member functions template<typename F> specify_postcondition_except< VirtualResult > old(F const &); template<typename F> specify_except postcondition(F const &); template<typename F> specify_nothing except(F const &); };DescriptionAllow to specify functors this library will call to copy old values at body, check postconditions, and check exception guarantees. This object is internally constructed by the library when users specify contracts calling boost::contract::function and similar functions (that is why this class does not have a public constructor).See Also: Old Values Copied at Body, Postconditions, Exception Guarantees Template Parameterstypename VirtualResult = voidReturn type of the enclosing function declaring the contract if that is either a virtual or an overriding public function, otherwise this is always void. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) <anchor id="boost.contract.specify__idm45394999245856construct-copy-destruct"/><computeroutput>specify_old_postcondition_except</computeroutput> public construct/copy/destruct~specify_old_postcondition_except();Destruct this object. Throws: This is declared noexcept(false) since C++11 to allow users to program failure handlers that throw exceptions on contract assertion failures (not the default, see Throw on Failure). <anchor id="idm45394999237760-bb"/><computeroutput>specify_old_postcondition_except</computeroutput> public member functionstemplate<typename F> specify_postcondition_except< VirtualResult > old(F const & f);Allow to specify old values copied at body. It should often be sufficient to initialize old value pointers as soon as they are declared, without using this function (see Old Values Copied at Body). Parameters:fNullary functor called by this library f() to assign old value copies just before the body is executed but after entry invariants (when they apply) and preconditions are checked. Old value pointers within this functor call are usually assigned using BOOST_CONTRACT_OLDOF. Any exception thrown by a call to this functor will result in this library calling boost::contract::old_failure (because old values could not be copied to check postconditions and exception guarantees). This functor should capture old value pointers by references so they can be assigned (all other variables needed to evaluate old value expressions can be captured by (constant) value, or better by (constant) reference to avoid extra copies).Returns:After old values copied at body have been specified, the object returned by this function allows to optionally specify postconditions and exception guarantees. template<typename F> specify_except postcondition(F const & f);Allow to specify postconditions. Parameters:fFunctor called by this library to check postconditions f() or f(result). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::postcondition_failure). This functor should capture variables by (constant) references (to access the values they will have at function exit). This functor must be a nullary functor f() if VirtualResult is void, otherwise it must be a unary functor f(result) accepting the return value result as a parameter of type VirtualResult const& (to avoid extra copies of the return value, or of type VirtualResult or VirtualResult const if extra copies of the return value are irrelevant).Returns:After postconditions have been specified, the object returned by this function allows to optionally specify exception guarantees. template<typename F> specify_nothing except(F const & f);Allow to specify exception guarantees. Parameters:fNullary functor called by this library to check exception guarantees f(). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::except_failure). This functor should capture variables by (constant) references (to access the values they will have at function exit).Returns:After exception guarantees have been specified, the object returned by this function does not allow to specify any additional contract. Class template specify_postcondition_except3boost::contract::specify_postcondition_exceptAllow to specify postconditions or exception guarantees. // In header: <boost/contract/core/specify.hpp> template<typename VirtualResult = void> class specify_postcondition_except { public: // construct/copy/destruct ~specify_postcondition_except(); // public member functions template<typename F> specify_except postcondition(F const &); template<typename F> specify_nothing except(F const &); };DescriptionAllow to specify functors this library will call to check postconditions or exception guarantees. This object is internally constructed by the library when users specify contracts calling boost::contract::function and similar functions (that is why this class does not have a public constructor).See Also: Postconditions, Exception Guarantees Template Parameterstypename VirtualResult = voidReturn type of the enclosing function declaring the contract if that is either a virtual or an overriding public function, otherwise this is always void. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) <anchor id="boost.contract.specify__idm45394999207792construct-copy-destruct"/><computeroutput>specify_postcondition_except</computeroutput> public construct/copy/destruct~specify_postcondition_except();Destruct this object. Throws: This is declared noexcept(false) since C++11 to allow users to program failure handlers that throw exceptions on contract assertion failures (not the default, see Throw on Failure). <anchor id="idm45394999200512-bb"/><computeroutput>specify_postcondition_except</computeroutput> public member functionstemplate<typename F> specify_except postcondition(F const & f);Allow to specify postconditions. Parameters:fFunctor called by this library to check postconditions f() or f(result). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::postcondition_failure). This functor should capture variables by (constant) references (to access the values they will have at function exit). This functor must be a nullary functor f() if VirtualResult is void, otherwise it must be a unary functor f(result) accepting the return value result as a parameter of type VirtualResult const& (to avoid extra copies of the return value, or of type VirtualResult or VirtualResult const if extra copies of the return value are irrelevant).Returns:After postconditions have been specified, the object returned by this function allows to optionally specify exception guarantees. template<typename F> specify_nothing except(F const & f);Allow to specify exception guarantees. Parameters:fNullary functor called by this library to check exception guarantees f(). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::except_failure). This functor should capture variables by (constant) references (to access the values they will have at function exit).Returns:After exception guarantees have been specified, the object returned by this function does not allow to specify any additional contract. Class template specify_precondition_old_postcondition_except3boost::contract::specify_precondition_old_postcondition_exceptAllow to specify preconditions, old values copied at body, postconditions, and exception guarantees. // In header: <boost/contract/core/specify.hpp> template<typename VirtualResult = void> class specify_precondition_old_postcondition_except { public: // construct/copy/destruct ~specify_precondition_old_postcondition_except(); // public member functions template<typename F> specify_old_postcondition_except< VirtualResult > precondition(F const &); template<typename F> specify_postcondition_except< VirtualResult > old(F const &); template<typename F> specify_except postcondition(F const &); template<typename F> specify_nothing except(F const &); };DescriptionAllow to specify functors this library will call to check preconditions, copy old values at body, check postconditions, and check exception guarantees. This object is internally constructed by the library when users specify contracts calling boost::contract::function and similar functions (that is why this class does not have a public constructor).See Also: Preconditions, Old Values Copied at Body, Postconditions, Exception Guarantees Template Parameterstypename VirtualResult = voidReturn type of the enclosing function declaring the contract if that is either a virtual or an overriding public function, otherwise this is always void. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) <anchor id="boost.contract.specify__idm45394999179040construct-copy-destruct"/><computeroutput>specify_precondition_old_postcondition_except</computeroutput> public construct/copy/destruct~specify_precondition_old_postcondition_except();Destruct this object. Throws: This is declared noexcept(false) since C++11 to allow users to program failure handlers that throw exceptions on contract assertion failures (not the default, see Throw on Failure). <anchor id="idm45394999170160-bb"/><computeroutput>specify_precondition_old_postcondition_except</computeroutput> public member functionstemplate<typename F> specify_old_postcondition_except< VirtualResult > precondition(F const & f);Allow to specify preconditions. Parameters:fNullary functor called by this library to check preconditions f(). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::precondition_failure). This functor should capture variables by (constant) value, or better by (constant) reference (to avoid extra copies).Returns:After preconditions have been specified, the object returned by this function allows to optionally specify old values copied at body, postconditions, and exception guarantees. template<typename F> specify_postcondition_except< VirtualResult > old(F const & f);Allow to specify old values copied at body. It should often be sufficient to initialize old value pointers as soon as they are declared, without using this function (see Old Values Copied at Body). Parameters:fNullary functor called by this library f() to assign old value copies just before the body is executed but after entry invariants (when they apply) and preconditions are checked. Old value pointers within this functor call are usually assigned using BOOST_CONTRACT_OLDOF. Any exception thrown by a call to this functor will result in this library calling boost::contract::old_failure (because old values could not be copied to check postconditions and exception guarantees). This functor should capture old value pointers by references so they can be assigned (all other variables needed to evaluate old value expressions can be captured by (constant) value, or better by (constant) reference to avoid extra copies).Returns:After old values copied at body have been specified, the object returned by this functions allows to optionally specify postconditions and exception guarantees. template<typename F> specify_except postcondition(F const & f);Allow to specify postconditions. Parameters:fFunctor called by this library to check postconditions f() or f(result). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::postcondition_failure). This functor should capture variables by (constant) references (to access the values they will have at function exit). This functor must be a nullary functor f() if VirtualResult is void, otherwise it must be a unary functor f(result) accepting the return value result as a parameter of type VirtualResult const& (to avoid extra copies of the return value, or of type VirtualResult or VirtualResult const if extra copies of the return value are irrelevant).Returns:After postconditions have been specified, the object returned by this function allows to optionally specify exception guarantees. template<typename F> specify_nothing except(F const & f);Allow to specify exception guarantees. Parameters:fNullary functor called by this library to check exception guarantees f(). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::except_failure). This functor should capture variables by (constant) references (to access the values they will have at function exit).Returns:After exception guarantees have been specified, the object returned by this function does not allow to specify any additional contract.

Header <<ulink url="../../../../boost/contract/core/virtual.hpp">boost/contract/core/virtual.hpp</ulink>>Handle virtual public functions with contracts (for subcontracting). namespace boost { namespace contract { class virtual_; } } Class virtual_3boost::contract::virtual_Type of extra function parameter to handle contracts for virtual public functions (for subcontracting). // In header: <boost/contract/core/virtual.hpp> class virtual_ { };DescriptionVirtual public functions (and therefore also public function overrides) declaring contracts using this library must specify an extra function parameter at the very end of their parameter list. This parameter must be a pointer to this class and it must have default value 0 or nullptr (this extra parameter is often named v in this documentation, but any name can be used):class u { public: virtual void f(int x, boost::contract::virtual_* v = 0) { // Declare `v`. ... // Contract declaration (which will use `v`) and function body. } ... }; In practice this extra parameter does not alter the calling interface of the enclosing function declaring the contract because it is always the very last parameter and it has a default value (so it can always be omitted when users call the function). This extra parameter must be passed to boost::contract::public_function, BOOST_CONTRACT_OLDOF, and all other operations of this library that accept a pointer to boost::contract::virtual_. A part from that, this class is not intended to be directly used by programmers (and that is why this class does not have any public member and it is not copyable).See Also: Virtual Public Functions, Public Function Overrides

Header <<ulink url="../../../../boost/contract/destructor.hpp">boost/contract/destructor.hpp</ulink>>Program contracts for destructors. namespace boost { namespace contract { template<typename Class> specify_old_postcondition_except destructor(Class *); } } Function template destructor3boost::contract::destructorProgram contracts for destructors. // In header: <boost/contract/destructor.hpp> template<typename Class> specify_old_postcondition_except destructor(Class * obj);DescriptionThis is used to specify postconditions, exception guarantees, old value copies at body, and check class invariants for destructors (destructors cannot have preconditions, see Destructor Calls):class u { friend class boost::contract::access; void invariant() const { // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... } public: ~u() { boost::contract::old_ptr<old_type> old_var; boost::contract::check c = boost::contract::destructor(this) // No `.precondition` (destructors have no preconditions). .old([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) .postcondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .except([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; ... // Destructor body. } ... }; For optimization, this can be omitted for destructors that do not have postconditions and exception guarantees, within classes that have no invariants.See Also: Destructors Parameters:objThe object this from the scope of the enclosing destructor declaring the contract. (Destructors check all class invariants, including static and volatile invariants, see Class Invariants and Volatile Public Functions).Template Parameters:ClassThe type of the class containing the destructor declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.)Returns:The result of this function must be assigned to a variable of type boost::contract::check declared explicitly (i.e., without using C++11 auto declarations) and locally just before the code of the destructor body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL).

Header <<ulink url="../../../../boost/contract/function.hpp">boost/contract/function.hpp</ulink>>Program contracts for (non-public) functions. namespace boost { namespace contract { specify_precondition_old_postcondition_except function(); } } Function function3boost::contract::functionProgram contracts for non-member, private and protected functions. // In header: <boost/contract/function.hpp> specify_precondition_old_postcondition_except function();DescriptionThis is used to specify preconditions, postconditions, exception guarantees, and old value copies at body for non-member, private and protected functions (these functions never check class invariants, see Function Calls):void f(...) { boost::contract::old_ptr<old_type> old_var; boost::contract::check c = boost::contract::function() .precondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .old([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) .postcondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .except([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; ... // Function body. } This can be used also to program contracts in implementation code for lambda functions, loops, and arbitrary blocks of code. For optimization, this can be omitted for code that does not have preconditions, postconditions, and exception guarantees.See Also: Non-Member Functions, Private and Protected Functions, Lambdas, Loops, Code Blocks Returns:The result of this function must be assigned to a variable of type boost::contract::check declared explicitly (i.e., without using C++11 auto declarations) and locally just before the code of the function body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL).

Header <<ulink url="../../../../boost/contract/old.hpp">boost/contract/old.hpp</ulink>>Handle old values. BOOST_CONTRACT_OLDOF(...)namespace boost { namespace contract { template<typename T> struct is_old_value_copyable; class old_pointer; template<typename T> class old_ptr; template<typename T> class old_ptr_if_copyable; class old_value; template<typename T> struct old_value_copy; old_value null_old(); old_pointer make_old(old_value const &); old_pointer make_old(virtual_ *, old_value const &); bool copy_old(); bool copy_old(virtual_ *); } } Struct template is_old_value_copyable3boost::contract::is_old_value_copyableTrait to check if an old value type can be copied or not. // In header: <boost/contract/old.hpp> template<typename T> struct is_old_value_copyable : public boost::is_copy_constructible< T > { };DescriptionBy default, this unary boolean meta-function is equivalent to boost::is_copy_constructible<T> but programmers can chose to specialize it for user-defined types (in general some kind of specialization is also needed on compilers that do not support C++11, see boost::is_copy_constructible):class u; // Some user-defined type for which old values shall not be copied. namespace boost { namespace contract { template<> // Specialization to not copy old values of type `u`. struct is_old_value_copyable : boost::false_type {}; } } // namespace A given old value type T is copied only if boost::contract::is_old_value_copyable<T>::value is true. A copyable old value type V is always copied using boost::contract::old_value_copy<V>. A non-copyable old value type W generates a compile-time error when boost::contract::old_ptr<W> is dereferenced, but instead leaves boost::contract::old_ptr_if_copyable<W> always null (without generating compile-time errors).See Also: Old Value Requirements Class old_pointer3boost::contract::old_pointerConvert old value copies into old value pointers. // In header: <boost/contract/old.hpp> class old_pointer { public: // public member functions template<typename T> operator old_ptr_if_copyable< T >(); template<typename T> operator old_ptr< T >(); };DescriptionThis class is usually only implicitly used by this library and it does not explicitly appear in user code (that is why this class does not have public constructors, etc.). <anchor id="idm45394999074832-bb"/><computeroutput>old_pointer</computeroutput> public member functionstemplate<typename T> operator old_ptr_if_copyable< T >();Convert this object to an actual old value pointer for which the old value type T might or not be copyable. For example, this is implicitly called when assigning or initializing old value pointers of type boost::contract::old_ptr_if_copyable. Template Parameters:TType of the pointed old value. The old value pointer will always be null if this type is not copyable (see boost::contract::is_old_value_copyable), but this library will not generate a compile-time error. template<typename T> operator old_ptr< T >();Convert this object to an actual old value pointer for which the old value type T must be copyable. For example, this is implicitly called when assigning or initializing old value pointers of type boost::contract::old_ptr. Template Parameters:TType of the pointed old value. This type must be copyable (see boost::contract::is_old_value_copyable), otherwise this library will generate a compile-time error when the old value pointer is dereferenced. Class template old_ptr3boost::contract::old_ptrOld value pointer that requires the pointed old value type to be copyable. // In header: <boost/contract/old.hpp> template<typename T> class old_ptr { public: // types typedef T element_type; // Pointed old value type. // construct/copy/destruct old_ptr(); // public member functions T const & operator *() const; T const * operator->() const; explicit operator bool() const; };DescriptionThis pointer can be set to point an actual old value copy using either BOOST_CONTRACT_OLDOF or boost::contract::make_old (that is why this class does not have public non-default constructors):class u { public: virtual void f(..., boost::contract::virtual_* v = 0) { boost::contract::old_ptr<old_type> old_var = // For copyable `old_type`. BOOST_CONTRACT_OLDOF(v, old_expr); ... } ... }; See Also: Old Values Template Parameterstypename TType of the pointed old value. This type must be copyable (i.e., boost::contract::is_old_value_copyable<T>::value must be true), otherwise this pointer will always be null and this library will generate a compile-time error when the pointer is dereferenced. <anchor id="boost.contract.old_ptrconstruct-copy-destruct"/><computeroutput>old_ptr</computeroutput> public construct/copy/destructold_ptr();Construct this old value pointer as null. <anchor id="idm45394999053440-bb"/><computeroutput>old_ptr</computeroutput> public member functionsT const & operator *() const;Dereference this old value pointer. This will generate a run-time error if this pointer is null and a compile-time error if the pointed type T is not copyable (i.e., if boost::contract::is_old_value_copyable<T>::value is false). Returns:The pointed old value. Contract assertions should not change the state of the program so this member function is const and it returns the old value as a reference to a constant object (see Constant Correctness). T const * operator->() const;Structure-dereference this old value pointer. This will generate a compile-time error if the pointed type T is not copyable (i.e., if boost::contract::is_old_value_copyable<T>::value is false). Returns:A pointer to the old value (null if this old value pointer is null). Contract assertions should not change the state of the program so this member function is const and it returns the old value as a pointer to a constant object (see Constant Correctness). explicit operator bool() const;Query if this old value pointer is null or not (safe-bool operator). (This is implemented using safe-bool emulation on compilers that do not support C++11 explicit type conversion operators.) Returns:True if this pointer is not null, false otherwise. Class template old_ptr_if_copyable3boost::contract::old_ptr_if_copyableOld value pointer that does not require the pointed old value type to be copyable. // In header: <boost/contract/old.hpp> template<typename T> class old_ptr_if_copyable { public: // types typedef T element_type; // Pointed old value type. // construct/copy/destruct old_ptr_if_copyable(); old_ptr_if_copyable(old_ptr< T > const &); // public member functions T const & operator *() const; T const * operator->() const; explicit operator bool() const; };DescriptionThis pointer can be set to point to an actual old value copy using either BOOST_CONTRACT_OLDOF or boost::contract::make_old:template<typename T> // Type `T` might or not be copyable. class u { public: virtual void f(..., boost::contract::virtual_* v = 0) { boost::contract::old_ptr_if_copyable<T> old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... if(old_var) ... // Always null for non-copyable types. ... } ... }; See Also: Old Value Requirements Template Parameterstypename TType of the pointed old value. If this type is not copyable (i.e., boost::contract::is_old_value_copyable<T>::value is false), this pointer will always be null (but this library will not generate a compile-time error when this pointer is dereferenced). <anchor id="boost.contract.old_ptr_if_copyableconstruct-copy-destruct"/><computeroutput>old_ptr_if_copyable</computeroutput> public construct/copy/destructold_ptr_if_copyable();Construct this old value pointer as null. old_ptr_if_copyable(old_ptr< T > const & other);Construct this old value pointer from an old value pointer that requires the old value type to be copyable. Ownership of the pointed value object is transferred to this pointer. This constructor is implicitly called by this library when assigning an object of this type using BOOST_CONTRACT_OLDOF (this constructor is usually not explicitly called by user code). Parameters:otherOld value pointer that requires the old value type to be copyable. <anchor id="idm45394999028256-bb"/><computeroutput>old_ptr_if_copyable</computeroutput> public member functionsT const & operator *() const;Dereference this old value pointer. This will generate a run-time error if this pointer is null, but no compile-time error is generated if the pointed type T is not copyable (i.e., if boost::contract::is_old_value_copyable<T>::value is false). Returns:The pointed old value. Contract assertions should not change the state of the program so this member function is const and it returns the old value as a reference to a constant object (see Constant Correctness). T const * operator->() const;Structure-dereference this old value pointer. This will return null but will not generate a compile-time error if the pointed type T is not copyable (i.e., if boost::contract::is_old_value_copyable<T>::value is false). Returns:A pointer to the old value (null if this old value pointer is null). Contract assertions should not change the state of the program so this member function is const and it returns the old value as a pointer to a constant object (see Constant Correctness). explicit operator bool() const;Query if this old value pointer is null or not (safe-bool operator). (This is implemented using safe-bool emulation on compilers that do not support C++11 explicit type conversion operators.) Returns:True if this pointer is not null, false otherwise. Class old_value3boost::contract::old_valueConvert user-specified expressions to old values. // In header: <boost/contract/old.hpp> class old_value { public: // construct/copy/destruct template<typename T> old_value(T const &, typename boost::enable_if< boost::contract::is_old_value_copyable< T > >::type * = 0); template<typename T> old_value(T const &, typename boost::disable_if< boost::contract::is_old_value_copyable< T > >::type * = 0); };DescriptionThis class is usually only implicitly used by this library and it does not explicitly appear in user code.On older compilers that cannot correctly deduce the boost::contract::is_old_value_copyable trait used in the declaration of this class, programmers can manually specialize that trait to make sure that only old value types that are copyable are actually copied.See Also: Old Value Requirements <anchor id="boost.contract.old_valueconstruct-copy-destruct"/><computeroutput>old_value</computeroutput> public construct/copy/destructtemplate<typename T> old_value(T const & old, typename boost::enable_if< boost::contract::is_old_value_copyable< T > >::type * = 0);Construct this object from the specified old value when the old value type is copy constructible. The specified old value old is copied (one time only) using boost::contract::old_value_copy, in which case the related old value pointer will not be null (but no copy is made if postconditions and exception guarantees are not being checked, see BOOST_CONTRACT_NO_OLDS). Parameters:oldOld value to be copied.Template Parameters:TOld value type. template<typename T> old_value(T const & old, typename boost::disable_if< boost::contract::is_old_value_copyable< T > >::type * = 0);Construct this object from the specified old value when the old value type is not copyable. The specified old value old cannot be copied in this case so it is not copied and the related old value pointer will always be null (thus calls to this constructor have no effect and they will likely be optimized away by most compilers). Parameters:oldOld value (that will not be copied in this case).Template Parameters:TOld value type. Struct template old_value_copy3boost::contract::old_value_copyTrait to copy an old value. // In header: <boost/contract/old.hpp> template<typename T> struct old_value_copy { // construct/copy/destruct explicit old_value_copy(T const &); // public member functions T const & old() const; };DescriptionBy default, the implementation of this trait uses T's copy constructor to make one single copy of the specified value. However, programmers can specialize this trait to copy old values using user-specific operations different from T's copy constructor. The default implementation of this trait is equivalent to:template<typename T> class old_value_copy { public: explicit old_value_copy(T const& old) : old_(old) // One single copy of value using T's copy constructor. {} T const& old() const { return old_; } private: T const old_; // The old value copy. }; This library will instantiate and use this trait only on old value types T that are copyable (i.e., for which boost::contract::is_old_value_copyable<T>::value is true).See Also: Old Value Requirements <anchor id="boost.contract.old_value_copyconstruct-copy-destruct"/><computeroutput>old_value_copy</computeroutput> public construct/copy/destructexplicit old_value_copy(T const & old);Construct this object by making one single copy of the specified old value. This is the only operation within this library that actually copies old values. This ensures this library makes one and only one copy of an old value (if they actually need to be copied, see BOOST_CONTRACT_NO_OLDS). Parameters:oldThe old value to copy. <anchor id="idm45394998981760-bb"/><computeroutput>old_value_copy</computeroutput> public member functionsT const & old() const;Return a (constant) reference to the old value that was copied. Contract assertions should not change the state of the program so the old value copy is returned as const (see Constant Correctness). Function null_old3boost::contract::null_oldReturn a "null" old value. // In header: <boost/contract/old.hpp> old_value null_old();DescriptionThe related old value pointer will also be null. This function is usually only called by the code expanded by BOOST_CONTRACT_OLDOF.See Also: No Macros Returns:Null old value. Function make_old3boost::contract::make_oldMake an old value pointer (but not for virtual public functions and public functions overrides). // In header: <boost/contract/old.hpp> old_pointer make_old(old_value const & old);DescriptionThe related old value pointer will not be null if the specified old value was actually copied. This function is usually only called by code expanded by BOOST_CONTRACT_OLDOF(old_expr) as in:boost::contract::make_old(boost::contract::copy_old() ? old_expr : boost::contract::null_old()) See Also: No Macros Parameters:oldOld value which is usually implicitly constructed from the user old value expression to be copied (use the ternary operator ?: to completely avoid to evaluate the old value expression when boost::contract::copy_old() is false).Returns:Old value pointer (usually implicitly converted to either boost::contract::old_ptr or boost::contract::old_ptr_if_copyable in user code). Function make_old3boost::contract::make_oldMake an old value pointer (for virtual public functions and public functions overrides). // In header: <boost/contract/old.hpp> old_pointer make_old(virtual_ * v, old_value const & old);DescriptionThe related old value pointer will not be null if the specified old value was actually copied. This function is usually only called by code expanded by BOOST_CONTRACT_OLDOF(v, old_expr) as in:boost::contract::make_old(v, boost::contract::copy_old(v) ? old_expr : boost::contract::null_old()) See Also: No Macros Parameters:oldOld value which is usually implicitly constructed from the user old value expression to be copied (use the ternary operator ?: to completely avoid to evaluate the old value expression when boost::contract::copy_old(v) is false).vThe trailing parameter of type boost::contract::virtual_* and default value 0 from the enclosing virtual or overriding public function declaring the contract. Returns:Old value pointer (usually implicitly converted to either boost::contract::old_ptr or boost::contract::old_ptr_if_copyable in user code). Function copy_old3boost::contract::copy_oldQuery if old values need to be copied (but not for virtual public functions and public function overrides). // In header: <boost/contract/old.hpp> bool copy_old();DescriptionFor example, this function always returns false when both postconditions and exception guarantees are not being checked (see BOOST_CONTRACT_NO_OLDS). This function is usually only called by the code expanded by BOOST_CONTRACT_OLDOF.See Also: No Macros Returns:True if old values need to be copied, false otherwise. Function copy_old3boost::contract::copy_oldQuery if old values need to be copied (for virtual public functions and public function overrides). // In header: <boost/contract/old.hpp> bool copy_old(virtual_ * v);DescriptionFor example, this function always returns false when both postconditions and exception guarantees are not being checked (see BOOST_CONTRACT_NO_OLDS). In addition, this function returns false when overridden functions are being called subsequent times by this library to support subcontracting. This function is usually only called by the code expanded by BOOST_CONTRACT_OLDOF.See Also: No Macros Parameters:vThe trailing parameter of type boost::contract::virtual_* and default value 0 from the enclosing virtual or overriding public function declaring the contract.Returns:True if old values need to be copied, false otherwise. Macro BOOST_CONTRACT_OLDOF3BOOST_CONTRACT_OLDOFMacro typically used to copy an old value expression and assign it to an old value pointer. // In header: <boost/contract/old.hpp> BOOST_CONTRACT_OLDOF(...)DescriptionThe expression expanded by this macro should be assigned to an old value pointer of type boost::contract::old_ptr or boost::contract::old_ptr_if_copyable. This is an overloaded variadic macro and it can be used in the following different ways.1. From within virtual public functions and public functions overrides:BOOST_CONTRACT_OLDOF(v, old_expr) 2. From all other operations:BOOST_CONTRACT_OLDOF(old_expr) Where: v is the extra parameter of type boost::contract::virtual_* and default value 0 from the enclosing virtual public function or public function overrides declaring the contract. old_expr is the expression to be evaluated and copied into the old value pointer. (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and BOOST_CONTRACT_OLDOF(v, (old_expr)) will always work.) On compilers that do not support variadic macros, programmers can manually copy old value expressions without using this macro (see No Macros).See Also: Old Values

Header <<ulink url="../../../../boost/contract/override.hpp">boost/contract/override.hpp</ulink>>Handle public function overrides (for subcontracting). BOOST_CONTRACT_NAMED_OVERRIDE(type_name, func_name) BOOST_CONTRACT_OVERRIDE(func_name) BOOST_CONTRACT_OVERRIDES(...) Macro BOOST_CONTRACT_NAMED_OVERRIDE3BOOST_CONTRACT_NAMED_OVERRIDEDeclare an override type trait with an arbitrary name. // In header: <boost/contract/override.hpp> BOOST_CONTRACT_NAMED_OVERRIDE(type_name, func_name)DescriptionDeclare the override type trait named type_name to pass as an explicit template parameter to boost::contract::public_function for public function overrides.See Also: Named Overrides Parameters:func_nameFunction name of the public function override. This macro is called just once even if the function name is overloaded (the same override type trait is used for all overloaded functions with the same name, see Function Overloads). (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) type_nameName of the override type trait this macro will declare. (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) Macro BOOST_CONTRACT_OVERRIDE3BOOST_CONTRACT_OVERRIDEDeclare an override type trait named override_func_name. // In header: <boost/contract/override.hpp> BOOST_CONTRACT_OVERRIDE(func_name)DescriptionDeclare the override type trait named override_func_name to pass as an explicit template parameter to boost::contract::public_function for public function overrides. Use BOOST_CONTRACT_NAMED_OVERRIDE to generate an override type trait with a name different than override_func_name (usually not needed).See Also: Public Function Overrides Parameters:func_nameFunction name of the public function override. This macro is called just once even if the function name is overloaded (the same override type trait is used for all overloaded functions with the same name, see Function Overloads). (This is not a variadic macro parameter but it should never contain any comma because it is an identifier.) Macro BOOST_CONTRACT_OVERRIDES3BOOST_CONTRACT_OVERRIDESDeclare multiple override type traits at once naming them override_... (for convenience). // In header: <boost/contract/override.hpp> BOOST_CONTRACT_OVERRIDES(...)DescriptionThis variadic macro is provided for convenience as BOOST_CONTRACT_OVERRIDES(f_1, f_2, ..., f_n) expands to code equivalent to:BOOST_CONTRACT_OVERRIDE(f_1) BOOST_CONTRACT_OVERRIDE(f_2) ... BOOST_CONTRACT_OVERRIDE(f_n) On compilers that do not support variadic macros, the override type traits can be equivalently programmed one-by-one calling BOOST_CONTRACT_OVERRIDE for each function name as shown above.See Also: Public Function Overrides Parameters:...A comma separated list of one or more function names of public function overrides. (Each function name should never contain commas because it is an identifier.)

Header <<ulink url="../../../../boost/contract/public_function.hpp">boost/contract/public_function.hpp</ulink>>Program contracts for public functions (including subcontracting). The different overloads handle public functions that are static, virtual void, virtual non-void, overriding void, and overriding non-void. namespace boost { namespace contract { template<typename Class> specify_precondition_old_postcondition_except public_function(); template<typename Class> specify_precondition_old_postcondition_except public_function(Class *); template<typename Class> specify_precondition_old_postcondition_except public_function(virtual_ *, Class *); template<typename VirtualResult, typename Class> specify_precondition_old_postcondition_except< VirtualResult > public_function(virtual_ *, VirtualResult &, Class *); template<typename Override, typename F, typename Class, typename... Args> specify_precondition_old_postcondition_except public_function(virtual_ *, F, Class *, Args &...); template<typename Override, typename VirtualResult, typename F, typename Class, typename... Args> specify_precondition_old_postcondition_except< VirtualResult > public_function(virtual_ *, VirtualResult &, F, Class *, Args &...); } } Function template public_function3boost::contract::public_functionProgram contracts for static public functions. // In header: <boost/contract/public_function.hpp> template<typename Class> specify_precondition_old_postcondition_except public_function();DescriptionThis is used to specify preconditions, postconditions, exception guarantees, old value copies at body, and check static class invariants for static public functions:class u { friend class boost::contract::access; static void static_invariant() { // Optional (as for non-static). BOOST_CONTRACT_ASSERT(...); ... } public: static void f(...) { boost::contract::old_ptr<old_type> old_var; boost::contract::check c = boost::contract::public_function() .precondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .old([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) .postcondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .except([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; ... // Function body. } ... }; For optimization, this can be omitted for static public functions that do not have preconditions, postconditions and exception guarantees, within classes that have no static invariants.See Also: Static Public Functions Template Parameters:ClassThe type of the class containing the static public function declaring the contract. This template parameter must be explicitly specified for static public functions (because they have no object this so there is no function argument from which this type template parameter can be automatically deduced by C++).Returns:The result of this function must be assigned to a variable of type boost::contract::check declared explicitly (i.e., without using C++11 auto declarations) and locally just before the code of the static public function body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL). Function template public_function3boost::contract::public_functionProgram contracts for public functions that are not static, not virtual, and do not not override. // In header: <boost/contract/public_function.hpp> template<typename Class> specify_precondition_old_postcondition_except public_function(Class * obj);DescriptionThis is used to specify preconditions, postconditions, exception guarantees, old value copies at body, and check class invariants for public functions that are not static, not virtual, and do not override:class u { friend class boost::contract::access; void invariant() const { // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... } public: void f(...) { boost::contract::old_ptr<old_type> old_var; boost::contract::check c = boost::contract::public_function(this) .precondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .old([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) .postcondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .except([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; ... // Function body. } ... }; For optimization, this can be omitted for public functions that do not have preconditions, postconditions and exception guarantees, within classes that have no invariants.See Also: Public Functions Parameters:objThe object this from the scope of the enclosing public function declaring the contract. This object might be mutable, const, volatile, or const volatile depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see Volatile Public Functions).Template Parameters:ClassThe type of the class containing the public function declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.)Returns:The result of this function must be assigned to a variable of type boost::contract::check declared explicitly (i.e., without using C++11 auto declarations) and locally just before the code of the public function body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL). Function template public_function3boost::contract::public_functionProgram contracts for void virtual public functions that do not override. // In header: <boost/contract/public_function.hpp> template<typename Class> specify_precondition_old_postcondition_except public_function(virtual_ * v, Class * obj);DescriptionThis is used to specify preconditions, postconditions, exception guarantees, old value copies at body, and check class invariants for public functions that are virtual, do not override, and return void: class u { friend class boost::contract::access; void invariant() const { // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... } public: void f(..., boost::contract::virtual_* v = 0) { boost::contract::old_ptr<old_type> old_var; boost::contract::check c = boost::contract::public_function(v, this) .precondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .old([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) .postcondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .except([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; ... // Function body. } ... }; A virtual public function should always call boost::contract::public_function otherwise this library will not be able to correctly use it for subcontracting.See Also: Virtual Public Functions Parameters:objThe object this from the scope of the enclosing virtual public function declaring the contract. This object might be mutable, const, volatile, or const volatile depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see Volatile Public Functions).vThe trailing parameter of type boost::contract::virtual_* and default value 0 from the enclosing virtual public function. Template Parameters:ClassThe type of the class containing the virtual public function declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.)Returns:The result of this function must be assigned to a variable of type boost::contract::check declared explicitly (i.e., without using C++11 auto declarations) and locally just before the code of the public function body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL). Function template public_function3boost::contract::public_functionProgram contracts for non-void virtual public functions that do not override. // In header: <boost/contract/public_function.hpp> template<typename VirtualResult, typename Class> specify_precondition_old_postcondition_except< VirtualResult > public_function(virtual_ * v, VirtualResult & r, Class * obj);DescriptionThis is used to specify preconditions, postconditions, exception guarantees, old value copies at body, and check class invariants for public functions that are virtual, do not override, and do not return void: class u { friend class boost::contract::access; void invariant() const { // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... } public: t f(..., boost::contract::virtual_* v = 0) { t result; boost::contract::old_ptr<old_type> old_var; boost::contract::check c = boost::contract::public_function( v, result, this) .precondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .old([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) .postcondition([&] (t const& result) { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .except([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; ... // Function body (use `return result = return_expr`). } ... }; A virtual public function should always call boost::contract::public_function otherwise this library will not be able to correctly use it for subcontracting.See Also: Virtual Public Functions Parameters:objThe object this from the scope of the enclosing virtual public function declaring the contract. This object might be mutable, const, volatile, or const volatile depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see Volatile Public Functions).rA reference to the return value of the enclosing virtual public function declaring the contract. This is usually a local variable declared by the enclosing virtual public function just before the contract, but programmers must set it to the actual value being returned by the function at each return statement. vThe trailing parameter of type boost::contract::virtual_* and default value 0 from the enclosing virtual public function. Template Parameters:ClassThe type of the class containing the virtual public function declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.)VirtualResultThis type must be the same as, or compatible with, the return type of the enclosing virtual public function declaring the contract (this library might not be able to generate a compile-time error if these types mismatch, but in general that will cause run-time errors or undefined behaviour). Alternatively, boost::optional<return-type> can also be used (see Optional Return Values). (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) Returns:The result of this function must be assigned to a variable of type boost::contract::check declared explicitly (i.e., without using C++11 auto declarations) and locally just before the code of the public function body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL). Function template public_function3boost::contract::public_functionProgram contracts for void public functions overrides (virtual or not). // In header: <boost/contract/public_function.hpp> template<typename Override, typename F, typename Class, typename... Args> specify_precondition_old_postcondition_except public_function(virtual_ * v, F f, Class * obj, Args &... args);DescriptionThis is used to specify preconditions, postconditions, exception guarantees, old value copies at body, and check class invariants for public function overrides (virtual or not) that return void: class u #define BASES private boost::contract::constructor_precondition, \ public b, private w : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES void invariant() const { // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... } BOOST_CONTRACT_OVERRIDES(f) public: // Override from `b::f`. void f(t_1 a_1, ..., t_n a_n, boost::contract::virtual_* v = 0) { boost::contract::old_ptr<old_type> old_var; boost::contract::check c = boost::contract::public_function< override_f>(v, &u::f, this, a_1, ..., a_n) .precondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .old([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) .postcondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .except([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; ... // Function body. } ... }; A public function override should always call boost::contract::public_function otherwise this library will not be able to correctly use it for subcontracting.See Also: Public Function Overrides Parameters:argsAll arguments passed to the enclosing public function override declaring the contract (by reference and in the order they appear in the enclosing function declaration), but excluding the trailing argument v.fA pointer to the enclosing public function override declaring the contract (but see Function Overloads). objThe object this from the scope of the enclosing public function override declaring the contract. This object might be mutable, const, volatile, or const volatile depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see Volatile Public Functions). vThe trailing parameter of type boost::contract::virtual_* and default value 0 from the enclosing public function override. Template Parameters:ArgsThe types of all parameters passed to the enclosing public function override declaring the contract, but excluding the trailing parameter type boost::contract::virtual_*. On compilers that do not support variadic templates, this library internally implements this function using preprocessor meta-programming (in this case, the maximum number of supported arguments is defined by BOOST_CONTRACT_MAX_ARGS). (Usually these template parameters are automatically deduced by C++ and they do not need to be explicitly specified by programmers.)ClassThe type of the class containing the virtual public function declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) FThe function pointer type of the enclosing public function override declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) OverrideThe type trait override_function-name declared using the BOOST_CONTRACT_OVERRIDE or related macros. This template parameter must be explicitly specified (because there is no function argument from which it can be automatically deduced by C++). Returns:The result of this function must be assigned to a variable of type boost::contract::check declared explicitly (i.e., without using C++11 auto declarations) and locally just before the code of the public function body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL). Function template public_function3boost::contract::public_functionProgram contracts for non-void public functions overrides (virtual or not). // In header: <boost/contract/public_function.hpp> template<typename Override, typename VirtualResult, typename F, typename Class, typename... Args> specify_precondition_old_postcondition_except< VirtualResult > public_function(virtual_ * v, VirtualResult & r, F f, Class * obj, Args &... args);DescriptionThis is used to specify preconditions, postconditions, exception guarantees, old value copies at body, and check class invariants for public function overrides (virtual or not) that do not return void: class u #define BASES private boost::contract::constructor_precondition, \ public b, private w : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES void invariant() const { // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... } BOOST_CONTRACT_OVERRIDES(f) public: // Override from `b::f`. t f(t_1 a_1, ..., t_n a_n, boost::contract::virtual_* v = 0) { t result; boost::contract::old_ptr<old_type> old_var; boost::contract::check c = boost::contract::public_function< override_f>(v, result, &u::f, this, a_1, ..., a_n) .precondition([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .old([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) .postcondition([&] (t const& result) { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) .except([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; ... // Function body (use `return result = return_expr`). } ... }; A public function override should always call boost::contract::public_function otherwise this library will not be able to correctly use it for subcontracting.See Also: Public Function Overrides Parameters:argsAll arguments passed to the enclosing public function override declaring the contract (by reference and in the order they appear in the enclosing function declaration), but excluding the trailing argument v.fA pointer to the enclosing public function override declaring the contract (but see Function Overloads). objThe object this from the scope of the enclosing public function override declaring the contract. This object might be mutable, const, volatile, or const volatile depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see Volatile Public Functions). rA reference to the return value of the enclosing public function override declaring the contract. This is usually a local variable declared by the enclosing public function override just before the contract, but programmers must set it to the actual value being returned by the function at each return statement. vThe trailing parameter of type boost::contract::virtual_* and default value 0 from the enclosing public function override. Template Parameters:ArgsThe types of all parameters passed to the enclosing public function override declaring the contract, but excluding the trailing parameter type boost::contract::virtual_*. On compilers that do not support variadic templates, this library internally implements this function using preprocessor meta-programming (in this case, the maximum number of supported arguments is defined by BOOST_CONTRACT_MAX_ARGS). (Usually these template parameters are automatically deduced by C++ and they do not need to be explicitly specified by programmers.)ClassThe type of the class containing the virtual public function declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) FThe function pointer type of the enclosing public function override declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) OverrideThe type trait override_function-name declared using the BOOST_CONTRACT_OVERRIDE or related macros. This template parameter must be explicitly specified (because there is no function argument from which it can be automatically deduced by C++). VirtualResultThis type must be the same as, or compatible with, the return type of the enclosing public function override declaring the contract (this library might not be able to generate a compile-time error if these types mismatch, but in general that will cause run-time errors or undefined behaviour). Alternatively, boost::optional<return-type> can also be used (see Optional Return Values). (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.) Returns:The result of this function must be assigned to a variable of type boost::contract::check declared explicitly (i.e., without using C++11 auto declarations) and locally just before the code of the public function body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL).

Header <<ulink url="../../../../boost/contract_macro.hpp">boost/contract_macro.hpp</ulink>>Allow to disable contracts to completely remove their compile-time and run-time overhead. This header automatically includes all header files boost/contract/*.hpp necessary to use its macros.Almost all the macros defined in this header file are variadic macros. On compilers that do not support variadic macros, programmers can manually code #ifndef BOOST_CONTRACT_NO_... statements instead (see Disable Contract Compilation). BOOST_CONTRACT_PRECONDITION(...) BOOST_CONTRACT_POSTCONDITION(...) BOOST_CONTRACT_EXCEPT(...) BOOST_CONTRACT_OLD(...) BOOST_CONTRACT_OLD_PTR(...) BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(...) BOOST_CONTRACT_INVARIANT(...) BOOST_CONTRACT_INVARIANT_VOLATILE(...) BOOST_CONTRACT_STATIC_INVARIANT(...) BOOST_CONTRACT_CONSTRUCTOR(...) BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(...) BOOST_CONTRACT_DESTRUCTOR(...) BOOST_CONTRACT_FUNCTION() BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(...) BOOST_CONTRACT_PUBLIC_FUNCTION(...) BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(...) Macro BOOST_CONTRACT_PRECONDITION3BOOST_CONTRACT_PRECONDITIONProgram preconditions that can be completely disabled at compile-time. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_PRECONDITION(...)DescriptionBOOST_CONTRACT_PRECONDITION(f) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_PRECONDITIONS is defined):#ifndef BOOST_CONTRACT_NO_PRECONDITIONS .precondition(f) #endif Where: f is the nullay functor called by this library to check preconditions f(). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::precondition_failure). This functor should capture variables by (constant) value, or better by (constant) reference (to avoid extra copies). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) See Also: Disable Contract Compilation, Preconditions Macro BOOST_CONTRACT_POSTCONDITION3BOOST_CONTRACT_POSTCONDITIONProgram postconditions that can be completely disabled at compile-time. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_POSTCONDITION(...)DescriptionBOOST_CONTRACT_POSTCONDITION(f) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_POSTCONDITIONS is defined):#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS .postcondition(f) #endif Where: f is the functor called by this library to check postconditions f() or f(result). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::postcondition_failure). This functor should capture variables by (constant) references (to access the values they will have at function exit). This functor takes the return value (preferably by const&) result as its one single parameter f(result) but only for virtual public functions and public functions overrides, otherwise it takes no parameter f(). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) See Also: Disable Contract Compilation, Postconditions Macro BOOST_CONTRACT_EXCEPT3BOOST_CONTRACT_EXCEPTProgram exception guarantees that can be completely disabled at compile-time. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_EXCEPT(...)DescriptionBOOST_CONTRACT_EXCEPT(f) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_EXCEPTS is defined):#ifndef BOOST_CONTRACT_NO_EXCEPTS .except(f) #endif Where: f is the nullary functor called by this library to check exception guarantees f(). Assertions within this functor are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling boost::contract::except_failure). This functor should capture variables by (constant) references (to access the values they will have at function exit). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) See Also: Disable Contract Compilation, Exception Guarantees Macro BOOST_CONTRACT_OLD3BOOST_CONTRACT_OLDProgram old value copies at body that can be completely disabled at compile-time. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_OLD(...)DescriptionBOOST_CONTRACT_OLD(f) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_OLDS is defined):#ifndef BOOST_CONTRACT_NO_OLDS .old(f) #endif Where: f is the nullary functor called by this library f() to assign old value copies just before the body is execute but after entry invariants (when they apply) and preconditions are checked. Old value pointers within this functor call are usually assigned using BOOST_CONTRACT_OLDOF. Any exception thrown by a call to this functor will result in this library calling boost::contract::old_failure (because old values could not be copied to check postconditions and exception guarantees). This functor should capture old value pointers by references so they can be assigned (all other variables needed to evaluate old value expressions can be captured by (constant) value, or better by (constant) reference to avoid extra copies). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) See Also: Disable Contract Compilation, Old Values Copied at Body Macro BOOST_CONTRACT_OLD_PTR3BOOST_CONTRACT_OLD_PTRProgram old values that can be completely disabled at compile-time for old value types that are required to be copyable. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_OLD_PTR(...)DescriptionThis is used to program old value copies for copyable types:class u { public: void f(...) { BOOST_CONTRACT_OLD_PTR(old_type_a)(old_var_a); // Null... BOOST_CONTRACT_OLD_PTR(old_type_b)(old_var_b, old_expr_b); // Set. BOOST_CONTRACT_PUBLIC_FUNCTION(this) ... BOOST_CONTRACT_OLD([&] { old_var_a = BOOST_CONTRACT_OLDOF(old_expr_a); // ...set. ... }) ... ; ... // Function body. } virtual void g(..., boost::contract::virtual_* v = 0) { BOOST_CONTRACT_OLD_PTR(old_type_a)(old_var_a); // No `v` BOOST_CONTRACT_OLD_PTR(old_type_b)(v, old_var_b, old_expr_b); // `v` BOOST_CONTRACT_PUBLIC_FUNCTION(v, this) ... BOOST_CONTRACT_OLD([&] { old_var_a = BOOST_CONTRACT_OLDOF(v, old_expr_a); // `v` ... }) ... ; ... // Function body. } ... }; This is an overloaded variadic macro and it can be used in the following different ways (note that no code is generated when BOOST_CONTRACT_NO_OLDS is defined).1. BOOST_CONTRACT_OLD_PTR(old_type)(old_var) expands to code equivalent to the following (this leaves the old value pointer null):#ifndef BOOST_CONTRACT_NO_OLDS // This declaration does not need to use `v`. boost::contract::old_ptr<old_type> old_var #endif 2. BOOST_CONTRACT_OLD_PTR(old_type)(old_var, old_expr) expands to code equivalent to the following (this initializes the pointer to the old value copy, but not to be used for virtual public functions and public function overrides):#ifndef BOOST_CONTRACT_NO_OLDS boost::contract::old_ptr<old_type> old_var = BOOST_CONTRACT_OLDOF(old_expr) #endif 3. BOOST_CONTRACT_OLD_PTR(old_type)(v, old_var, old_expr) expands to code equivalent to the following (this initializes the pointer to the old value copy for virtual public functions and public function overrides):#ifndef BOOST_CONTRACT_NO_OLDS boost::contract::old_ptr<old_type> old_var = BOOST_CONTRACT_OLDOF(v, old_expr) #endif Where: old_type is the type of the pointed old value. This type must be copyable (i.e., boost::contract::is_old_value_copyable<old_type>::value is true), otherwise this pointer will always be null and this library will generate a compile-time error when the pointer is dereferenced (see BOOST_CONTRACT_OLD_PTR_IF_COPYABLE). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) (Rationale: Template parameters like this one are specified to this library macro interface using their own set of parenthesis SOME_MACRO(template_params)(other_params).) v is the extra training parameter of type boost::contract::virtual_* and default value 0 from the enclosing virtual public function or public function override declaring the contract. (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) old_var is the name of the old value pointer variable. (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) old_expr is the expression to be evaluated and copied in the old value pointer. (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and BOOST_CONTRACT_OLD_PTR(old_type)(v, old_var, (old_expr)) will always work.) See Also: Disable Contract Compilation, Old Values Macro BOOST_CONTRACT_OLD_PTR_IF_COPYABLE3BOOST_CONTRACT_OLD_PTR_IF_COPYABLEProgram old values that can be completely disabled at compile-time for old value types that are not required to be copyable. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(...)DescriptionThis is used to program old value copies for types that might or might not be copyable:template<typename T> // Type `T` might or not be copyable. class u { public: void f(...) { BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type_a)(old_var_a); BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type_b)(old_var_b, old_expr_b); BOOST_CONTRACT_PUBLIC_FUNCTION(this) ... BOOST_CONTRACT_OLD([&] { old_var_a = BOOST_CONTRACT_OLDOF(old_expr_a); ... }) ... // In postconditions or exception guarantees: if(old_var_a) ... // Always null for non-copyable types. if(old_var_b) ... // Always null for non-copyable types. ... ; ... // Function body. } virtual void g(..., boost::contract::virtual_* v = 0) { BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type_a)(old_var_a); BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type_b)(v, old_var_b, old_expr_b); BOOST_CONTRACT_PUBLIC_FUNCTION(v, this) ... BOOST_CONTRACT_OLD([&] { old_var_a = BOOST_CONTRACT_OLDOF(v, old_expr_a); ... }) ... // In postconditions or exception guarantees: if(old_var_a) ... // Always null for non-copyable types. if(old_var_b) ... // Always null for non-copyable types. ... ; ... // Function body. } ... }; This is an overloaded variadic macro and it can be used in the following different ways (note that no code is generated when BOOST_CONTRACT_NO_OLDS is defined).1. BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(old_var) expands to code equivalent to the following (this leaves the old value pointer null):#ifndef BOOST_CONTRACT_NO_OLDS // This declaration does not need to use `v`. boost::contract::old_ptr_if_copyable<old_type> old_var #endif 2. BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(old_var, old_expr) expands to code equivalent to the following (this initializes the pointer to the old value copy, but not to be used for virtual public functions and public function overrides):#ifndef BOOST_CONTRACT_NO_OLDS boost::contract::old_ptr_if_copyable<old_type> old_var = BOOST_CONTRACT_OLDOF(old_expr) #endif 3. BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(v, old_var, old_expr) expands to code equivalent to the following (this initializes the pointer to the old value copy for virtual public functions and public function overrides):#ifndef BOOST_CONTRACT_NO_OLDS boost::contract::old_ptr_if_copyable<old_type> old_var = BOOST_CONTRACT_OLDOF(v, old_expr) #endif Where: old_type is the type of the pointed old value. If this type is not copyable (i.e., boost::contract::is_old_value_copyable<old_type>::value is false), this pointer will always be null, but this library will not generate a compile-time error when this pointer is dereferenced (see BOOST_CONTRACT_OLD_PTR). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) v is the extra trailing parameter of type boost::contract::virtual_* and default value 0 from the enclosing virtual public function or public function override declaring the contract. (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) old_var is the name of the old value pointer variable. (This is not a variadic macro parameter but it should never contain commas because it is an identifier.) old_expr is the expression to be evaluated and copied in the old value pointer. (This is not a variadic macro parameter so any comma it might contain must be protected by round parenthesis and BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(v, old_var, (old_expr)) will always work.) See Also: Disable Contract Compilation, Old Value Requirements Macro BOOST_CONTRACT_INVARIANT3BOOST_CONTRACT_INVARIANTProgram (constant) class invariants that can be completely disabled at compile-time. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_INVARIANT(...)DescriptionBOOST_CONTRACT_INVARIANT({ ... }) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_INVARIANTS is defined):#ifndef BOOST_CONTRACT_NO_INVARIANTS void BOOST_CONTRACT_INVARIANT_FUNC() const { ... } #endif Where: { ... } is the definition of the function that checks class invariants for public functions that are not static and not volatile (see BOOST_CONTRACT_STATIC_INVARIANT and BOOST_CONTRACT_INVARIANT_VOLATILE). The curly parenthesis are mandatory (rationale: this is so the syntax of this macro resembles mote the syntax of the lambda functions usually used to specify preconditions, etc.). Assertions within this function are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this function indicates a contract assertion failure (and will result in this library calling either boost::contract::entry_invariant_failure or boost::contract::exit_invariant_failure). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) See Also: Disable Contract Compilation, Class Invariants Macro BOOST_CONTRACT_INVARIANT_VOLATILE3BOOST_CONTRACT_INVARIANT_VOLATILEProgram volatile class invariants that can be completely disabled at compile-time. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_INVARIANT_VOLATILE(...)DescriptionBOOST_CONTRACT_INVARIANT_VOLATILE({ ... }) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_INVARIANTS is defined):#ifndef BOOST_CONTRACT_NO_INVARIANTS void BOOST_CONTRACT_INVARIANT_FUNC() const volatile { ... } #endif Where: { ... } is the definition of the function that checks class invariants for volatile public functions (see BOOST_CONTRACT_INVARIANT and BOOST_CONTRACT_STATIC_INVARIANT). The curly parenthesis are mandatory. Assertions within this function are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this function indicates a contract assertion failure (and will result in this library calling either boost::contract::entry_invariant_failure or boost::contract::exit_invariant_failure). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) See Also: Disable Contract Compilation, Volatile Public Functions Macro BOOST_CONTRACT_STATIC_INVARIANT3BOOST_CONTRACT_STATIC_INVARIANTProgram static class invariants that can be completely disabled at compile-time. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_STATIC_INVARIANT(...)DescriptionBOOST_CONTRACT_STATIC_INVARIANT({ ... }) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_INVARIANTS is defined):#ifndef BOOST_CONTRACT_NO_INVARIANTS static void BOOST_CONTRACT_STATIC_INVARIANT_FUNC() { ... } #endif Where: { ... } is the definition of the function that checks class invariants for static public functions (see BOOST_CONTRACT_INVARIANT and BOOST_CONTRACT_INVARIANT_VOLATILE). The curly parenthesis are mandatory. Assertions within this function are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this function indicates a contract assertion failure (and will result in this library calling either boost::contract::entry_invariant_failure or boost::contract::exit_invariant_failure). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) See Also: Disable Contract Compilation, Class Invariants Macro BOOST_CONTRACT_CONSTRUCTOR3BOOST_CONTRACT_CONSTRUCTORProgram contracts that can be completely disabled at compile-time for constructors. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_CONSTRUCTOR(...)DescriptionThis is used together with BOOST_CONTRACT_POSTCONDITION, BOOST_CONTRACT_EXCEPT, and BOOST_CONTRACT_OLD to specify postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for constructors (see BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION to specify preconditions for constructors):class u { friend class boost::contract::access; BOOST_CONTRACT_INVARIANT({ // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... }) public: u(...) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_CONSTRUCTOR(this) // No `PRECONDITION` (use `CONSTRUCTOR_PRECONDITION` if needed). BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_epxr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Constructor body. } ... }; For optimization, this can be omitted for constructors that do not have postconditions and exception guarantees, within classes that have no invariants.BOOST_CONTRACT_CONSTRUCTOR(obj) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_CONSTRUCTORS is defined):#ifndef BOOST_CONTRACT_NO_CONSTRUCTORS boost::contract::check internal_var = boost::contract::constructor(obj) #endif Where: obj is the object this from the scope of the enclosing constructor declaring the contract. Constructors check all class invariants, including static and volatile invariants (see BOOST_CONTRACT_INVARIANT, BOOST_CONTRACT_STATIC_INVARIANT, and BOOST_CONTRACT_INVARIANT_VOLATILE). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) internal_var is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). See Also: Disable Contract Compilation, Constructors Macro BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION3BOOST_CONTRACT_CONSTRUCTOR_PRECONDITIONProgram preconditions that can be disabled at compile-time for constructors. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(...)DescriptionThis is used together with BOOST_CONTRACT_CONSTRUCTOR to specify contracts for constructors. Constructors that do not have preconditions do not use this macro. When at least one of the class constructors uses this macro, boost::contract::constructor_precondition must be the first and private base of the class declaring the constructor for which preconditions are programmed:class u #define BASES private boost::contract::constructor_precondition, \ public b : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES ... public: explicit u(unsigned x) : BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(u)([&] { BOOST_CONTRACT_ASSERT(x != 0); }), b(1 / x) { ... } ... }; BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(class_type)(f) expands to code equivalent to the following (note that when BOOST_CONTRACT_NO_PRECONDITIONS is defined, this macro trivially expands to a default constructor call that is internally implemented to do nothing so this should have minimal to no overhead):// Guarded only by NO_PRECONDITIONS (and not also by NO_CONSTRUCTORS) // because for constructor's preconditions (not for postconditions, etc.). #ifndef BOOST_CONTRACT_NO_PRECONDITIONS boost::contract::constructor_precondition<class_type>(f) #else // No-op call (likely optimized away, minimal to no overhead). boost::contract::constructor_precondition<class_type>() #endif Where: class_type is the type of the class containing the constructor for which preconditions are being programmed. (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) f is the nullary functor called by this library to check constructor preconditions f(). Assertions within this functor call are usually programmed using BOOST_CONTRACT_ASSERT, but any exception thrown by a call to this functor indicates a contract failure (and will result in this library calling boost::contract::precondition_failure). This functor should capture variables by (constant) value, or better by (constant) reference to avoid extra copies. (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) See Also: Disable Contract Compilation, Constructors Macro BOOST_CONTRACT_DESTRUCTOR3BOOST_CONTRACT_DESTRUCTORProgram contracts that can be completely disabled at compile-time for destructors. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_DESTRUCTOR(...)DescriptionThis is used together with BOOST_CONTRACT_POSTCONDITION, BOOST_CONTRACT_EXCEPT, and BOOST_CONTRACT_OLD to specify postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for destructors (destructors cannot have preconditions, see Destructor Calls):class u { friend class boost::contract::access; BOOST_CONTRACT_INVARIANT({ // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... }) public: ~u() { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_DESTRUCTOR(this) // No `PRECONDITION` (destructors have no preconditions). BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Destructor body. } ... }; For optimization, this can be omitted for destructors that do not have postconditions and exception guarantees, within classes that have no invariants.BOOST_CONTRACT_DESTRUCTOR(obj) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_DESTRUCTORS is defined):#ifndef BOOST_CONTRACT_NO_DESTRUCTORS boost::contract::check internal_var = boost::contract::destructor(obj) #endif Where: obj is the object this from the scope of the enclosing destructor declaring the contract. Destructors check all class invariants, including static and volatile invariants (see Class Invariants and Volatile Public Functions). (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) internal_var is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). See Also: Disable Contract Compilation, Destructors Macro BOOST_CONTRACT_FUNCTION3BOOST_CONTRACT_FUNCTIONProgram contracts that can be completely disabled at compile-time for (non-public) functions. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_FUNCTION()DescriptionThis is used together with BOOST_CONTRACT_PRECONDITION, BOOST_CONTRACT_POSTCONDITION, BOOST_CONTRACT_EXCEPT, and BOOST_CONTRACT_OLD to specify preconditions, postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for (non-public) functions:void f(...) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_FUNCTION() BOOST_CONTRACT_PRECONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Function body. } This can be used to program contracts for non-member functions but also for private and protected functions, lambda functions, loops, arbitrary blocks of code, etc. For optimization, this can be omitted for code that does not have preconditions, postconditions, and exception guarantees.BOOST_CONTRACT_FUNCTION() expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_FUNCTIONS is defined):#ifndef BOOST_CONTRACT_NO_FUNCTIONS boost::contract::check internal_var = boost::contract::function() #endif Where: internal_var is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). See Also: Disable Contract Compilation, Non-Member Functions, Private and Protected Functions, Lambdas, Loops, Code Blocks Macro BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION3BOOST_CONTRACT_STATIC_PUBLIC_FUNCTIONProgram contracts that can be completely disabled at compile-time for static public functions. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(...)DescriptionThis is used together with BOOST_CONTRACT_PRECONDITION, BOOST_CONTRACT_POSTCONDITION, BOOST_CONTRACT_EXCEPT, and BOOST_CONTRACT_OLD to specify preconditions, postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for static public functions:class u { friend class boost::contract::access; BOOST_CONTRACT_STATIC_INVARIANT({ // Optional (as for non-static). BOOST_CONTRACT_ASSERT(...); ... }) public: static void f(...) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION(u) BOOST_CONTRACT_PRECONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Function body. } ... }; For optimization, this can be omitted for static public functions that do not have preconditions, postconditions and exception guarantees, within classes that have no static invariants.BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(class_type) expands to code equivalent to the following (note that no code is generated when BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS is defined):#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract::public_function<class_type>() #endif Where: class_type is the type of the class containing the static public function declaring the contract. (This is a variadic macro parameter so it can contain commas not protected by round parenthesis.) internal_var is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). See Also: Disable Contract Compilation, Static Public Functions Macro BOOST_CONTRACT_PUBLIC_FUNCTION3BOOST_CONTRACT_PUBLIC_FUNCTIONProgram contracts that can be completely disabled at compile-time for non-static public functions that do not override. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_PUBLIC_FUNCTION(...)DescriptionThis is used together with BOOST_CONTRACT_PRECONDITION, BOOST_CONTRACT_POSTCONDITION, BOOST_CONTRACT_EXCEPT, and BOOST_CONTRACT_OLD to specify preconditions, postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for non-static public functions (virtual or not, void or not) that do not override:class u { friend class boost::contract::access; BOOST_CONTRACT_INVARIANT({ // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... }) public: // Non-virtual (same if void). t f(...) { t result; BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION(this) BOOST_CONTRACT_PRECONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Function body (use `return result = return_expr`). } // Virtual and void. virtual void g(..., boost::contract::virtual_* v = 0) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION(v, this) ... BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) ... ; // Trailing `;` is required. ... // Function body. } // Virtual and non-void. virtual t h(..., boost::contract::virtual_* v = 0) { t result; BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION(v, result, this) ... BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] (t const& result) { // Optional BOOST_CONTRACT_ASSERT(...); ... }) ... ; // Trailing `;` is required. ... // Function body (use `return result = return_expr`). } ... }; For optimization, this can be omitted for non-virtual public functions that do not have preconditions, postconditions and exception guarantees, within classes that have no invariants. Virtual public functions should always use BOOST_CONTRACT_PUBLIC_FUNCTION otherwise this library will not be able to correctly use them for subcontracting.This is an overloaded variadic macro and it can be used in the following different ways (note that no code is generated when BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS is defined).1. BOOST_CONTRACT_PUBLIC_FUNCTION(obj) expands to code equivalent to the following (for non-virtual public functions that are not static and do not override, returning void or not):#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract::public_function(obj) #endif 2. BOOST_CONTRACT_PUBLIC_FUNCTION(v, obj) expands to code equivalent to the following (for virtual public functions that do not override, returning void):#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract::public_function(v, obj) #endif 3. BOOST_CONTRACT_PUBLIC_FUNCTION(v, r, obj) expands to code equivalent to the following (for virtual public functions that do not override, not returning void):#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract::public_function(v, r, obj) #endif Where (these are all variadic macro parameters so they can contain commas not protected by round parenthesis): v is the extra parameter of type boost::contract::virtual_* and default value 0 from the enclosing virtual public function declaring the contract. r is a reference to the return value of the enclosing virtual public function declaring the contract. This is usually a local variable declared by the enclosing virtual public function just before the contract, but programmers must set it to the actual value being returned by the function at each return statement. obj is the object this from the scope of the enclosing public function declaring the contract. This object might be mutable, const, volatile, or const volatile depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see Volatile Public Functions). internal_var is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). See Also: Disable Contract Compilation, Public Functions, Virtual Public Functions Macro BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE3BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDEProgram contracts that can be completely disabled at compile-time for public function overrides. // In header: <boost/contract_macro.hpp> BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(...)DescriptionThis is used together with BOOST_CONTRACT_PRECONDITION, BOOST_CONTRACT_POSTCONDITION, BOOST_CONTRACT_EXCEPT, and BOOST_CONTRACT_OLD to specify preconditions, postconditions, exception guarantees, and old value copies at body that can be completely disabled at compile-time for public function overrides (virtual or not):class u #define BASES private boost::contract::constructor_precondition, \ public b, private w : BASES { friend class boost::contract::access; typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types; #undef BASES BOOST_CONTRACT_INVARIANT({ // Optional (as for static and volatile). BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OVERRIDES(f, g) public: // Override from `b::f`, and void. void f(t_1 a_1, ..., t_n a_n, boost::contract::virtual_* v = 0) { BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_f)( v, &u::f, this, a_1, ..., a_n) BOOST_CONTRACT_PRECONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) BOOST_CONTRACT_EXCEPT([&] { // Optional. BOOST_CONTRACT_ASSERT(...); ... }) ; // Trailing `;` is required. ... // Function body. } // Override from `b::g`, and void. t g(t_1 a_1, ..., t_n a_n, boost::contract::virtual_* v = 0) { t result; BOOST_CONTRACT_OLD_PTR(old_type)(old_var); BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_g)( v, result, &u::g, this, a_1, ..., a_n) ... BOOST_CONTRACT_OLD([&] { // Optional. old_var = BOOST_CONTRACT_OLDOF(v, old_expr); ... }) BOOST_CONTRACT_POSTCONDITION([&] (t const& result) { // Optional BOOST_CONTRACT_ASSERT(...); ... }) ... ; // Trailing `;` is required. ... // Function body (use `return result = return_expr`). } ... }; Public function overrides should always use BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE otherwise this library will not be able to correctly use it for subcontracting.This is an overloaded variadic macro and it can be used in the following different ways (note that no code is generated when BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS is defined).1. BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_type)(v, f, obj, ...) expands to code equivalent to the following (for public function overrides that return void):#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract:: public_function<override_type>(v, f, obj, ...) #endif 2. BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_type)(v, r, f, obj, ...) expands to code equivalent to the following (for public function overrides that do not return void):#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS boost::contract::check internal_var = boost::contract:: public_function<override_type>(v, r, f, obj, ...) #endif Where (these are all variadic macro parameters so they can contain commas not protected by round parenthesis): override_type is the type override_function-name declared using the BOOST_CONTRACT_OVERRIDE or related macros. v is the extra parameter of type boost::contract::virtual_* and default value 0 from the enclosing virtual public function declaring the contract. r is a reference to the return value of the enclosing virtual public function declaring the contract. This is usually a local variable declared by the enclosing virtual public function just before the contract, but programmers must set it to the actual value being returned by the function at each return statement. f is a pointer to the enclosing public function override declaring the contract. obj is the object this from the scope of the enclosing public function declaring the contract. This object might be mutable, const, volatile, or const volatile depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see Volatile Public Functions). ... is a variadic macro parameter listing all the arguments passed to the enclosing public function override declaring the contract (by reference and in the order they appear in the enclosing function declaration), but excluding the trailing argument v. internal_var is a variable name internally generated by this library (this name is unique but only on different line numbers so this macro cannot be expanded multiple times on the same line). See Also: Disable Contract Compilation, Public Function Overrides