63e88f80
 Hu Chunming
提交三方库
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
#ifndef BOOST_CONTRACT_ASSERT_HPP_
#define BOOST_CONTRACT_ASSERT_HPP_
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
/** @file
Assert contract conditions.
*/
#include <boost/contract/core/config.hpp>
#include <boost/contract/detail/noop.hpp>
#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
/**
Preferred way to assert contract conditions.
Any 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 @c false (this
library will then call the appropriate contract failure handler
@RefFunc{boost::contract::precondition_failure}, etc.).
However, it is preferred to use this macro because it expands to
code that throws @RefClass{boost::contract::assertion_failure} with the
correct assertion file name (using <c>__FILE__</c>), line number (using
<c>__LINE__</c>), and asserted condition code so to produce informative
error messages (C++11 <c>__func__</c> 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).
@RefMacro{BOOST_CONTRACT_ASSERT}, @RefMacro{BOOST_CONTRACT_ASSERT_AUDIT},
and @RefMacro{BOOST_CONTRACT_ASSERT_AXIOM} are the three assertion levels
predefined by this library.
@see @RefSect{tutorial.preconditions, Preconditions},
@RefSect{tutorial.postconditions, Postconditions},
@RefSect{tutorial.exception_guarantees, Exceptions Guarantees},
@RefSect{tutorial.class_invariants, Class Invariants},
@RefSect{extras.no_macros__and_no_variadic_macros_, No Macros}
@param cond Boolean contract condition to check.
(This is not a variadic macro parameter so any comma it might
contain must be protected by round parenthesis and
@c BOOST_CONTRACT_ASSERT((cond)) will always work.)
*/
// This must be an expression (a trivial one so the compiler can optimize it
// away). It cannot an empty code block `{}`, etc. otherwise code like
// `if(...) ASSERT(...); else ASSERT(...);` won't work when NO_ALL.
#define BOOST_CONTRACT_ASSERT(cond)
#elif !defined(BOOST_CONTRACT_NO_ALL)
#include <boost/contract/detail/assert.hpp>
#define BOOST_CONTRACT_ASSERT(cond) \
BOOST_CONTRACT_DETAIL_ASSERT(cond) /* no `;` here */
#else
// This must be an expression (a trivial one so the compiler can optimize it
// away). It cannot an empty code block `{}`, etc. otherwise code like
// `if(...) ASSERT(...); else ASSERT(...);` won't work when NO_ALL.
#define BOOST_CONTRACT_ASSERT(cond) \
BOOST_CONTRACT_DETAIL_NOOP
#endif
#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
/**
Preferred way to assert contract conditions that are computationally
expensive, at least compared to the computational cost of executing the
function body.
The asserted condition will always be compiled and validated syntactically,
but it will not be checked at run-time unless
@RefMacro{BOOST_CONTRACT_AUDITS} is defined (undefined by default).
This macro is defined by code equivalent to:
@code
#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
@endcode
@RefMacro{BOOST_CONTRACT_ASSERT}, @RefMacro{BOOST_CONTRACT_ASSERT_AUDIT},
and @RefMacro{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 @RefSect{extras.assertion_levels, Assertion Levels},
@RefSect{extras.no_macros__and_no_variadic_macros_, No Macros}
@param cond Boolean contract condition to check.
(This is not a variadic macro parameter so any comma it might
contain must be protected by round parenthesis and
@c BOOST_CONTRACT_ASSERT_AUDIT((cond)) will always work.)
*/
#define BOOST_CONTRACT_ASSERT_AUDIT(cond)
#elif defined(BOOST_CONTRACT_AUDITS)
#define BOOST_CONTRACT_ASSERT_AUDIT(cond) \
BOOST_CONTRACT_ASSERT(cond)
#else
#define BOOST_CONTRACT_ASSERT_AUDIT(cond) \
BOOST_CONTRACT_DETAIL_NOEVAL(cond)
#endif
/**
Preferred way to document in the code contract conditions that are
computationally prohibitive, at least compared to the computational cost of
executing the function body.
The 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:
@code
#define BOOST_CONTRACT_ASSERT_AXIOM(cond) \
BOOST_CONTRACT_ASSERT(true || cond)
@endcode
@RefMacro{BOOST_CONTRACT_ASSERT}, @RefMacro{BOOST_CONTRACT_ASSERT_AUDIT}, and
@RefMacro{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 @RefSect{extras.assertion_levels, Assertion Levels},
@RefSect{extras.no_macros__and_no_variadic_macros_, No Macros}
@param cond Boolean contract condition to check.
(This is not a variadic macro parameter so any comma it might
contain must be protected by round parenthesis and
@c BOOST_CONTRACT_ASSERT_AXIOM((cond)) will always work.)
*/
#define BOOST_CONTRACT_ASSERT_AXIOM(cond) \
BOOST_CONTRACT_DETAIL_NOEVAL(cond)
#endif // #include guard
|
