FM / boost

/usr/include/boost

Name	Size	Mode	Actions
accumulators/	-	0755	rm
algorithm/	-	0755	rm
align/	-	0755	rm
archive/	-	0755	rm
asio/	-	0755	rm
assert/	-	0755	rm
assign/	-	0755	rm
atomic/	-	0755	rm
beast/	-	0755	rm
bimap/	-	0755	rm
bind/	-	0755	rm
callable_traits/	-	0755	rm
chrono/	-	0755	rm
circular_buffer/	-	0755	rm
compatibility/	-	0755	rm
compute/	-	0755	rm
concept/	-	0755	rm
concept_check/	-	0755	rm
config/	-	0755	rm
container/	-	0755	rm
container_hash/	-	0755	rm
context/	-	0755	rm
contract/	-	0755	rm
convert/	-	0755	rm
core/	-	0755	rm
coroutine/	-	0755	rm
coroutine2/	-	0755	rm
date_time/	-	0755	rm
detail/	-	0755	rm
dll/	-	0755	rm
dynamic_bitset/	-	0755	rm
endian/	-	0755	rm
exception/	-	0755	rm
fiber/	-	0755	rm
filesystem/	-	0755	rm
flyweight/	-	0755	rm
format/	-	0755	rm
function/	-	0755	rm
functional/	-	0755	rm
function_types/	-	0755	rm
fusion/	-	0755	rm
geometry/	-	0755	rm
gil/	-	0755	rm
graph/	-	0755	rm
hana/	-	0755	rm
heap/	-	0755	rm
histogram/	-	0755	rm
hof/	-	0755	rm
icl/	-	0755	rm
integer/	-	0755	rm
interprocess/	-	0755	rm
intrusive/	-	0755	rm
io/	-	0755	rm
iostreams/	-	0755	rm
iterator/	-	0755	rm
lambda/	-	0755	rm
lexical_cast/	-	0755	rm
locale/	-	0755	rm
local_function/	-	0755	rm
lockfree/	-	0755	rm
log/	-	0755	rm
logic/	-	0755	rm
math/	-	0755	rm
metaparse/	-	0755	rm
move/	-	0755	rm
mp11/	-	0755	rm
mpi/	-	0755	rm
mpl/	-	0755	rm
msm/	-	0755	rm
multiprecision/	-	0755	rm
multi_array/	-	0755	rm
multi_index/	-	0755	rm
nowide/	-	0755	rm
numeric/	-	0755	rm
optional/	-	0755	rm
outcome/	-	0755	rm
parameter/	-	0755	rm
pending/	-	0755	rm
phoenix/	-	0755	rm
polygon/	-	0755	rm
poly_collection/	-	0755	rm
pool/	-	0755	rm
predef/	-	0755	rm
preprocessor/	-	0755	rm
process/	-	0755	rm
program_options/	-	0755	rm
property_map/	-	0755	rm
property_tree/	-	0755	rm
proto/	-	0755	rm
ptr_container/	-	0755	rm
python/	-	0755	rm
qvm/	-	0755	rm
random/	-	0755	rm
range/	-	0755	rm
ratio/	-	0755	rm
regex/	-	0755	rm
safe_numerics/	-	0755	rm
serialization/	-	0755	rm
signals2/	-	0755	rm
smart_ptr/	-	0755	rm
sort/	-	0755	rm
spirit/	-	0755	rm
stacktrace/	-	0755	rm
statechart/	-	0755	rm
static_string/	-	0755	rm
stl_interfaces/	-	0755	rm
system/	-	0755	rm
test/	-	0755	rm
thread/	-	0755	rm
timer/	-	0755	rm
tti/	-	0755	rm
tuple/	-	0755	rm
typeof/	-	0755	rm
type_erasure/	-	0755	rm
type_index/	-	0755	rm
type_traits/	-	0755	rm
units/	-	0755	rm
unordered/	-	0755	rm
utility/	-	0755	rm
uuid/	-	0755	rm
variant/	-	0755	rm
variant2/	-	0755	rm
vmd/	-	0755	rm
wave/	-	0755	rm
winapi/	-	0755	rm
xpressive/	-	0755	rm
yap/	-	0755	rm
align.hpp	633	0644	edit dl rm
aligned_storage.hpp	653	0644	edit dl rm
any.hpp	9472	0644	edit dl rm
array.hpp	15827	0644	edit dl rm
asio.hpp	7472	0644	edit dl rm
assert.hpp	2625	0644	edit dl rm
assign.hpp	592	0644	edit dl rm
atomic.hpp	754	0644	edit dl rm
beast.hpp	591	0644	edit dl rm
bimap.hpp	387	0644	edit dl rm
bind.hpp	1809	0644	edit dl rm
blank.hpp	1985	0644	edit dl rm
blank_fwd.hpp	618	0644	edit dl rm
callable_traits.hpp	2138	0644	edit dl rm
call_traits.hpp	633	0644	edit dl rm
cast.hpp	584	0644	edit dl rm
cerrno.hpp	4187	0644	edit dl rm
checked_delete.hpp	414	0644	edit dl rm
chrono.hpp	706	0644	edit dl rm
circular_buffer.hpp	1946	0644	edit dl rm
circular_buffer_fwd.hpp	1137	0644	edit dl rm
compressed_pair.hpp	653	0644	edit dl rm
compute.hpp	1523	0644	edit dl rm
concept_archetype.hpp	23725	0644	edit dl rm
concept_check.hpp	31977	0644	edit dl rm
config.hpp	2216	0644	edit dl rm
contract.hpp	1842	0644	edit dl rm
contract_macro.hpp	56497	0644	edit dl rm
convert.hpp	7402	0644	edit dl rm
crc.hpp	94883	0644	edit dl rm
cregex.hpp	721	0644	edit dl rm
cstdfloat.hpp	2611	0644	edit dl rm
cstdint.hpp	18497	0644	edit dl rm
cstdlib.hpp	1739	0644	edit dl rm
current_function.hpp	1681	0644	edit dl rm
cxx11_char_types.hpp	4160	0644	edit dl rm
date_time.hpp	540	0644	edit dl rm
dll.hpp	712	0644	edit dl rm
dynamic_bitset.hpp	560	0644	edit dl rm
dynamic_bitset_fwd.hpp	675	0644	edit dl rm
enable_shared_from_this.hpp	525	0644	edit dl rm
endian.hpp	364	0644	edit dl rm
exception_ptr.hpp	396	0644	edit dl rm
filesystem.hpp	862	0644	edit dl rm
flyweight.hpp	604	0644	edit dl rm
foreach.hpp	45551	0644	edit dl rm
foreach_fwd.hpp	1702	0644	edit dl rm
format.hpp	2179	0644	edit dl rm
function.hpp	2524	0644	edit dl rm
functional.hpp	20124	0644	edit dl rm
function_equal.hpp	791	0644	edit dl rm
function_output_iterator.hpp	630	0644	edit dl rm
generator_iterator.hpp	2028	0644	edit dl rm
geometry.hpp	704	0644	edit dl rm
get_pointer.hpp	2288	0644	edit dl rm
gil.hpp	1697	0644	edit dl rm
hana.hpp	6807	0644	edit dl rm
histogram.hpp	1312	0644	edit dl rm
hof.hpp	2009	0644	edit dl rm
implicit_cast.hpp	810	0644	edit dl rm
indirect_reference.hpp	1036	0644	edit dl rm
integer.hpp	11593	0644	edit dl rm
integer_fwd.hpp	5181	0644	edit dl rm
integer_traits.hpp	8319	0644	edit dl rm
intrusive_ptr.hpp	481	0644	edit dl rm
io_fwd.hpp	1879	0644	edit dl rm
is_placeholder.hpp	634	0644	edit dl rm
iterator.hpp	459	0644	edit dl rm
iterator_adaptors.hpp	466	0644	edit dl rm
lexical_cast.hpp	3275	0644	edit dl rm
limits.hpp	6156	0644	edit dl rm
locale.hpp	887	0644	edit dl rm
local_function.hpp	18858	0644	edit dl rm
make_default.hpp	1510	0644	edit dl rm
make_shared.hpp	464	0644	edit dl rm
make_unique.hpp	293	0644	edit dl rm
math_fwd.hpp	975	0644	edit dl rm
memory_order.hpp	2457	0644	edit dl rm
mem_fn.hpp	596	0644	edit dl rm
metaparse.hpp	5281	0644	edit dl rm
mp11.hpp	641	0644	edit dl rm
mpi.hpp	1101	0644	edit dl rm
multi_array.hpp	18021	0644	edit dl rm
multi_index_container.hpp	44983	0644	edit dl rm
multi_index_container_fwd.hpp	3776	0644	edit dl rm
next_prior.hpp	5127	0644	edit dl rm
noncopyable.hpp	402	0644	edit dl rm
nondet_random.hpp	532	0644	edit dl rm
none.hpp	1609	0644	edit dl rm
none_t.hpp	953	0644	edit dl rm
non_type.hpp	619	0644	edit dl rm
operators.hpp	36574	0644	edit dl rm
operators_v1.hpp	37735	0644	edit dl rm
optional.hpp	528	0644	edit dl rm
outcome.hpp	1699	0644	edit dl rm
parameter.hpp	1082	0644	edit dl rm
phoenix.hpp	476	0644	edit dl rm
pointee.hpp	1807	0644	edit dl rm
pointer_cast.hpp	3688	0644	edit dl rm
pointer_to_other.hpp	1197	0644	edit dl rm
polymorphic_cast.hpp	5282	0644	edit dl rm
polymorphic_pointer_cast.hpp	2829	0644	edit dl rm
predef.h	635	0644	edit dl rm
preprocessor.hpp	487	0644	edit dl rm
process.hpp	1366	0644	edit dl rm
program_options.hpp	820	0644	edit dl rm
progress.hpp	5734	0644	edit dl rm
python.hpp	2950	0644	edit dl rm
random.hpp	3854	0644	edit dl rm
range.hpp	603	0644	edit dl rm
ratio.hpp	349	0644	edit dl rm
rational.hpp	39720	0644	edit dl rm
ref.hpp	370	0644	edit dl rm
regex.h	2174	0644	edit dl rm
regex.hpp	823	0644	edit dl rm
regex_fwd.hpp	693	0644	edit dl rm
scoped_array.hpp	506	0644	edit dl rm
scoped_ptr.hpp	497	0644	edit dl rm
scope_exit.hpp	54745	0644	edit dl rm
shared_array.hpp	536	0644	edit dl rm
shared_container_iterator.hpp	2154	0644	edit dl rm
shared_ptr.hpp	525	0644	edit dl rm
signals2.hpp	752	0644	edit dl rm
smart_ptr.hpp	780	0644	edit dl rm
spirit.hpp	1133	0644	edit dl rm
stacktrace.hpp	499	0644	edit dl rm
static_assert.hpp	7213	0644	edit dl rm
static_string.hpp	423	0644	edit dl rm
swap.hpp	374	0644	edit dl rm
thread.hpp	839	0644	edit dl rm
throw_exception.hpp	4328	0644	edit dl rm
timer.hpp	2781	0644	edit dl rm
tokenizer.hpp	2783	0644	edit dl rm
token_functions.hpp	19349	0644	edit dl rm
token_iterator.hpp	3810	0644	edit dl rm
type.hpp	481	0644	edit dl rm
type_index.hpp	10757	0644	edit dl rm
type_traits.hpp	7431	0644	edit dl rm
unordered_map.hpp	568	0644	edit dl rm
unordered_set.hpp	568	0644	edit dl rm
utility.hpp	880	0644	edit dl rm
variant.hpp	883	0644	edit dl rm
version.hpp	1117	0644	edit dl rm
visit_each.hpp	690	0644	edit dl rm
wave.hpp	944	0644	edit dl rm
weak_ptr.hpp	462	0644	edit dl rm

Edit: /usr/include/boost/contract_macro.hpp (56497B)

#ifndef BOOST_CONTRACT_MACRO_HPP_
#define BOOST_CONTRACT_MACRO_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
Allow to disable contracts to completely remove their compile-time and run-time
overhead.
This header automatically includes all header files <c>boost/contract/\*.hpp</c>
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
<c>\#ifndef BOOST_CONTRACT_NO_...</c> statements instead (see
@RefSect{extras.disable_contract_compilation__macro_interface_,
Disable Contract Compilation}).
*/

// IMPORTANT: Following headers can always be #included (without any #if-guard)
// because they expand to trivial code that does not affect compile-time. These
// headers must always be #included here (without any #if-guard) because they
// define types and macros that are typically left in user code even when
// contracts are disables (these types and macros never affect run-time and
// their definitions are trivial when contracts are disabled so their impact on
// compile-time is negligible).
#include <boost/contract/override.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/core/constructor_precondition.hpp>
#include <boost/contract/core/check_macro.hpp>
#include <boost/contract/core/access.hpp>
#include <boost/contract/core/virtual.hpp>
#include <boost/contract/core/exception.hpp>
#include <boost/contract/core/config.hpp>

#ifndef BOOST_CONTRACT_NO_CONDITIONS
 #include <boost/contract/assert.hpp>
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
    /**
    Program preconditions that can be completely disabled at compile-time.

@c BOOST_CONTRACT_PRECONDITION(f) expands to code equivalent to the
 following (note that no code is generated when
 @RefMacro{BOOST_CONTRACT_NO_PRECONDITIONS} is defined):
 
 @code
 #ifndef BOOST_CONTRACT_NO_PRECONDITIONS
 .precondition(f)
 #endif
 @endcode
 
 Where:
 
 @arg <c>f</c> is the nullay functor called by this library to
 check preconditions @c f().
 Assertions within this functor are usually programmed using
 @RefMacro{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
 @RefFunc{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    @RefSect{extras.disable_contract_compilation__macro_interface_,
            Disable Contract Compilation},
            @RefSect{tutorial.preconditions, Preconditions}
    */
    #define BOOST_CONTRACT_PRECONDITION(...)
#elif !defined(BOOST_CONTRACT_NO_PRECONDITIONS)
    #define BOOST_CONTRACT_PRECONDITION(...) .precondition(__VA_ARGS__)
#else
    #define BOOST_CONTRACT_PRECONDITION(...) /* nothing */
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
    /**
    Program postconditions that can be completely disabled at compile-time.

@c BOOST_CONTRACT_POSTCONDITION(f) expands to code equivalent to the
    following (note that no code is generated when
    @RefMacro{BOOST_CONTRACT_NO_POSTCONDITIONS} is defined):
    
    @code
    #ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
        .postcondition(f)
    #endif
    @endcode
    
    Where:

@arg <c>f</c> is the functor called by this library to check
 postconditions @c f() or @c f(result).
 Assertions within this functor are usually programmed using
 @RefMacro{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
 @RefFunc{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 <c>const&</c>)
 @c result as its one single parameter @c f(result) but only for
 virtual public functions and public functions overrides, otherwise
 it takes no parameter @c f().
 (This is a variadic macro parameter so it can contain commas not
 protected by round parenthesis.)

@see    @RefSect{extras.disable_contract_compilation__macro_interface_,
            Disable Contract Compilation},
            @RefSect{tutorial.postconditions, Postconditions}
    */
    #define BOOST_CONTRACT_POSTCONDITION(...)
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
    #define BOOST_CONTRACT_POSTCONDITION(...) .postcondition(__VA_ARGS__)
#else
    #define BOOST_CONTRACT_POSTCONDITION(...) /* nothing */
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
 /**
 Program exception guarantees that can be completely disabled at
 compile-time.
 
 @c BOOST_CONTRACT_EXCEPT(f) expands to code equivalent to the following
 (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_EXCEPTS}
 is defined):
 
 @code
 #ifndef BOOST_CONTRACT_NO_EXCEPTS
 .except(f)
 #endif
 @endcode
 
 Where:
 
 @arg <c>f</c> is the nullary functor called by this library to
 check exception guarantees @c f().
 Assertions within this functor are usually programmed using
 @RefMacro{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
 @RefFunc{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    @RefSect{extras.disable_contract_compilation__macro_interface_,
            Disable Contract Compilation},
            @RefSect{tutorial.exception_guarantees, Exception Guarantees}
    */
    #define BOOST_CONTRACT_EXCEPT(...)
#elif !defined(BOOST_CONTRACT_NO_EXCEPTS)
    #define BOOST_CONTRACT_EXCEPT(...) .except(__VA_ARGS__)
#else
    #define BOOST_CONTRACT_EXCEPT(...) /* nothing */
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
    /**
    Program old value copies at body that can be completely disabled at
    compile-time.

@c BOOST_CONTRACT_OLD(f) expands to code equivalent to the following (note
    that no code is generated when @RefMacro{BOOST_CONTRACT_NO_OLDS} is
    defined):
    
    @code
    #ifndef BOOST_CONTRACT_NO_OLDS
        .old(f)
    #endif
    @endcode
    
    Where:

@arg <c>f</c> is the nullary functor called by this library
 @c 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 @RefMacro{BOOST_CONTRACT_OLDOF}.
 Any exception thrown by a call to this functor will result in
 this library calling @RefFunc{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    @RefSect{extras.disable_contract_compilation__macro_interface_,
            Disable Contract Compilation},
            @RefSect{advanced.old_values_copied_at_body,
            Old Values Copied at Body}
    */
    #define BOOST_CONTRACT_OLD(...)

/**
    Program old values that can be completely disabled at compile-time for old
    value types that are required to be copyable.

This is used to program old value copies for copyable types:

@code
    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.
        }

...
    };
    @endcode
    
    This is an overloaded variadic macro and it can be used in the following
    different ways (note that no code is generated when
    @RefMacro{BOOST_CONTRACT_NO_OLDS} is defined).

1\. <c>BOOST_CONTRACT_OLD_PTR(old_type)(old_var)</c> expands to code
 equivalent to the following (this leaves the old value pointer null):

@code
 #ifndef BOOST_CONTRACT_NO_OLDS
 // This declaration does not need to use `v`.
 boost::contract::old_ptr<old_type> old_var
 #endif
 @endcode
 
 2\. <c>BOOST_CONTRACT_OLD_PTR(old_type)(old_var, old_expr)</c> 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):
 
 @code
 #ifndef BOOST_CONTRACT_NO_OLDS
 boost::contract::old_ptr<old_type> old_var =
 BOOST_CONTRACT_OLDOF(old_expr)
 #endif
 @endcode
 
 3\. <c>BOOST_CONTRACT_OLD_PTR(old_type)(v, old_var, old_expr)</c> expands to
 code equivalent to the following (this initializes the pointer to the
 old value copy for virtual public functions and public function
 overrides):

@code
 #ifndef BOOST_CONTRACT_NO_OLDS
 boost::contract::old_ptr<old_type> old_var =
 BOOST_CONTRACT_OLDOF(v, old_expr)
 #endif
 @endcode
 
 Where:
 
 @arg <c>old_type</c> is the type of the pointed old value.
 This type must be copyable (i.e.,
 <c>boost::contract::is_old_value_copyable<old_type>::value</c> is
 @c true), otherwise this pointer will always be null and this
 library will generate a compile-time error when the pointer is
 dereferenced (see @RefMacro{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
 <c>SOME_MACRO(template_params)(other_params)</c>.)
 @arg <c>v</c> is the extra training parameter of type
 @RefClass{boost::contract::virtual_}<c>*</c> and default value @c 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.)
 @arg <c>old_var</c> 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.)
 @arg <c>old_expr</c> 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
 <c>BOOST_CONTRACT_OLD_PTR(old_type)(v, old_var, (old_expr))</c>
 will always work.)

@see    @RefSect{extras.disable_contract_compilation__macro_interface_,
            Disable Contract Compilation},
            @RefSect{tutorial.old_values, Old Values}
    */
    #define BOOST_CONTRACT_OLD_PTR(...)

/**
    Program old values that can be completely disabled at compile-time for old
    value types that are not required to be copyable.
    
    This is used to program old value copies for types that might or might not
    be copyable:

@code
 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.
        }

1\. <c>BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(old_var)</c> expands to
 code equivalent to the following (this leaves the old value pointer
 null):

@code
 #ifndef BOOST_CONTRACT_NO_OLDS
 // This declaration does not need to use `v`.
 boost::contract::old_ptr_if_copyable<old_type> old_var
 #endif
 @endcode
 
 2\. <c>BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(old_var, old_expr)</c>
 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):
 
 @code
 #ifndef BOOST_CONTRACT_NO_OLDS
 boost::contract::old_ptr_if_copyable<old_type> old_var =
 BOOST_CONTRACT_OLDOF(old_expr)
 #endif
 @endcode
 
 3\. <c>BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(v, old_var,
 old_expr)</c> expands to code equivalent to the following (this
 initializes the pointer to the old value copy for virtual public
 functions and public function overrides):

@code
 #ifndef BOOST_CONTRACT_NO_OLDS
 boost::contract::old_ptr_if_copyable<old_type> old_var =
 BOOST_CONTRACT_OLDOF(v, old_expr)
 #endif
 @endcode
 
 Where:
 
 @arg <c>old_type</c> is the type of the pointed old value.
 If this type is not copyable (i.e.,
 <c>boost::contract::is_old_value_copyable<old_type>::value</c> is
 @c false), this pointer will always be null, but this library will
 not generate a compile-time error when this pointer is dereferenced
 (see @RefMacro{BOOST_CONTRACT_OLD_PTR}).
 (This is a variadic macro parameter so it can contain commas not
 protected by round parenthesis.)
 @arg <c>v</c> is the extra trailing parameter of type
 @RefClass{boost::contract::virtual_}<c>*</c> and default value @c 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.)
 @arg <c>old_var</c> 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.)
 @arg <c>old_expr</c> 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
 <c>BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(old_type)(v, old_var,
 (old_expr))</c> will always work.)

@see @RefSect{extras.disable_contract_compilation__macro_interface_,
 Disable Contract Compilation},
 @RefSect{extras.old_value_requirements__templates_,
 Old Value Requirements}
 */
 #define BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(...)
#elif !defined(BOOST_CONTRACT_NO_OLDS)
 #include <boost/contract/old.hpp>
 #include <boost/preprocessor/facilities/overload.hpp>
 #include <boost/preprocessor/facilities/empty.hpp>
 #include <boost/preprocessor/cat.hpp>

/* PRIVATE */

#define BOOST_CONTRACT_OLD_VAR_1(ptr) \
        ptr
    #define BOOST_CONTRACT_OLD_VAR_2(ptr, expr) \
        ptr = BOOST_CONTRACT_OLDOF(expr)
    #define BOOST_CONTRACT_OLD_VAR_3(v, ptr, expr) \
        ptr = BOOST_CONTRACT_OLDOF(v, expr)

#define BOOST_CONTRACT_OLD_VAR_(...) \
        BOOST_PP_CAT(BOOST_PP_OVERLOAD(BOOST_CONTRACT_OLD_VAR_, __VA_ARGS__) \
                (__VA_ARGS__), BOOST_PP_EMPTY())

/* PUBLIC */
    
    #define BOOST_CONTRACT_OLD(...) .old(__VA_ARGS__)

#define BOOST_CONTRACT_OLD_PTR(...) \
 boost::contract::old_ptr< __VA_ARGS__ > \
 BOOST_CONTRACT_OLD_VAR_

#define BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(...) \
 boost::contract::old_ptr_if_copyable< __VA_ARGS__ > \
 BOOST_CONTRACT_OLD_VAR_
#else
 #include <boost/preprocessor/tuple/eat.hpp>
 
 #define BOOST_CONTRACT_OLD(...) /* nothing */

#define BOOST_CONTRACT_OLD_PTR(...) BOOST_PP_TUPLE_EAT(0)
    
    #define BOOST_CONTRACT_OLD_PTR_IF_COPYABLE(...) BOOST_PP_TUPLE_EAT(0)
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
    /**
    Program (constant) class invariants that can be completely disabled at
    compile-time.

@c BOOST_CONTRACT_INVARIANT({ ... }) expands to code equivalent to the
    following (note that no code is generated when
    @RefMacro{BOOST_CONTRACT_NO_INVARIANTS} is defined):

@code
 #ifndef BOOST_CONTRACT_NO_INVARIANTS
 void BOOST_CONTRACT_INVARIANT_FUNC() const {
 ...
 }
 #endif
 @endcode
 
 Where:
 
 @arg { ... } is the definition of the function that checks class
 invariants for public functions that are not static and not volatile
 (see @RefMacro{BOOST_CONTRACT_STATIC_INVARIANT} and
 @RefMacro{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
 @RefMacro{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
 @RefFunc{boost::contract::entry_invariant_failure} or
 @RefFunc{boost::contract::exit_invariant_failure}).
 (This is a variadic macro parameter so it can contain commas not
 protected by round parenthesis.)

@see    @RefSect{extras.disable_contract_compilation__macro_interface_,
            Disable Contract Compilation},
            @RefSect{tutorial.class_invariants, Class Invariants}
    */
    #define BOOST_CONTRACT_INVARIANT(...)

/**
    Program volatile class invariants that can be completely disabled at
    compile-time.

@c BOOST_CONTRACT_INVARIANT_VOLATILE({ ... }) expands to code equivalent to
    the following (note that no code is generated when
    @RefMacro{BOOST_CONTRACT_NO_INVARIANTS} is defined):

@code
 #ifndef BOOST_CONTRACT_NO_INVARIANTS
 void BOOST_CONTRACT_INVARIANT_FUNC() const volatile {
 ...
 }
 #endif
 @endcode
 
 Where:
 
 @arg { ... } is the definition of the function that checks class
 invariants for volatile public functions
 (see @RefMacro{BOOST_CONTRACT_INVARIANT} and
 @RefMacro{BOOST_CONTRACT_STATIC_INVARIANT}).
 The curly parenthesis are mandatory.
 Assertions within this function are usually programmed using
 @RefMacro{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
 @RefFunc{boost::contract::entry_invariant_failure} or
 @RefFunc{boost::contract::exit_invariant_failure}).
 (This is a variadic macro parameter so it can contain commas not
 protected by round parenthesis.)

@see    @RefSect{extras.disable_contract_compilation__macro_interface_,
            Disable Contract Compilation},
            @RefSect{extras.volatile_public_functions,
            Volatile Public Functions}
    */
    #define BOOST_CONTRACT_INVARIANT_VOLATILE(...)
    
    /**
    Program static class invariants that can be completely disabled at
    compile-time.

@c BOOST_CONTRACT_STATIC_INVARIANT({ ... }) expands to code equivalent to
    the following (note that no code is generated when
    @RefMacro{BOOST_CONTRACT_NO_INVARIANTS} is defined):

@code
 #ifndef BOOST_CONTRACT_NO_INVARIANTS
 static void BOOST_CONTRACT_STATIC_INVARIANT_FUNC() {
 ...
 }
 #endif
 @endcode
 
 Where:
 
 @arg { ... } is the definition of the function that checks class
 invariants for static public functions
 (see @RefMacro{BOOST_CONTRACT_INVARIANT} and
 @RefMacro{BOOST_CONTRACT_INVARIANT_VOLATILE}).
 The curly parenthesis are mandatory.
 Assertions within this function are usually programmed using
 @RefMacro{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
 @RefFunc{boost::contract::entry_invariant_failure} or
 @RefFunc{boost::contract::exit_invariant_failure}).
 (This is a variadic macro parameter so it can contain commas not
 protected by round parenthesis.)

#define BOOST_CONTRACT_INVARIANT(...) \
        void BOOST_CONTRACT_INVARIANT_FUNC() const __VA_ARGS__

#define BOOST_CONTRACT_INVARIANT_VOLATILE(...) \
        void BOOST_CONTRACT_INVARIANT_FUNC() const volatile __VA_ARGS__
    
    #define BOOST_CONTRACT_STATIC_INVARIANT(...) \
        static void BOOST_CONTRACT_STATIC_INVARIANT_FUNC() __VA_ARGS__
#else
    #define BOOST_CONTRACT_INVARIANT(...) /* nothing */

#define BOOST_CONTRACT_INVARIANT_VOLATILE(...) /* nothing */
    
    #define BOOST_CONTRACT_STATIC_INVARIANT(...) /* nothing */
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
    /**
    Program contracts that can be completely disabled at compile-time for
    constructors.
    
    This is used together with @RefMacro{BOOST_CONTRACT_POSTCONDITION},
    @RefMacro{BOOST_CONTRACT_EXCEPT}, and @RefMacro{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
    @RefMacro{BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION} to specify preconditions
    for constructors):

@code
    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.
        }

...
    };
    @endcode

For optimization, this can be omitted for constructors that do not have
    postconditions and exception guarantees, within classes that have no
    invariants.
            
    @c BOOST_CONTRACT_CONSTRUCTOR(obj) expands to code equivalent to the
    following (note that no code is generated when
    @RefMacro{BOOST_CONTRACT_NO_CONSTRUCTORS} is defined):

@code
        #ifndef BOOST_CONTRACT_NO_CONSTRUCTORS
            boost::contract::check internal_var =
                    boost::contract::constructor(obj)
        #endif
    @endcode

Where:
 
 @arg <c>obj</c> is the object @c this from the scope of the
 enclosing constructor declaring the contract.
 Constructors check all class invariants, including static and
 volatile invariants (see @RefMacro{BOOST_CONTRACT_INVARIANT},
 @RefMacro{BOOST_CONTRACT_STATIC_INVARIANT}, and
 @RefMacro{BOOST_CONTRACT_INVARIANT_VOLATILE}).
 (This is a variadic macro parameter so it can contain commas not
 protected by round parenthesis.)
 @arg <c>internal_var</c> 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 @RefSect{extras.disable_contract_compilation__macro_interface_,
 Disable Contract Compilation},
 @RefSect{tutorial.constructors, Constructors}
 */
 #define BOOST_CONTRACT_CONSTRUCTOR(...)
#elif !defined(BOOST_CONTRACT_NO_CONSTRUCTORS)
 #include <boost/contract/constructor.hpp>
 #include <boost/contract/check.hpp>
 #include <boost/contract/detail/name.hpp>

#define BOOST_CONTRACT_CONSTRUCTOR(...) \
        boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \
                boost::contract::constructor(__VA_ARGS__)
#else
    #define BOOST_CONTRACT_CONSTRUCTOR(...) /* nothing */
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
    /**
    Program preconditions that can be disabled at compile-time for constructors.
            
    This is used together with @RefMacro{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,
    @RefClass{boost::contract::constructor_precondition} must be the first and
    private base of the class declaring the constructor for which preconditions
    are programmed:

@code
 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)
        {
            ...
        }

...
    };
    @endcode

<c>BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(class_type)(f)</c> expands
 to code equivalent to the following (note that when
 @RefMacro{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):

@code
 // 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
 
 @endcode
 
 Where:

@arg <c>class_type</c> 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.)
 @arg <c>f</c> is the nullary functor called by this library to
 check constructor preconditions @c f().
 Assertions within this functor call are usually programmed using
 @RefMacro{BOOST_CONTRACT_ASSERT}, but any exception thrown by a call
 to this functor indicates a contract failure (and will result in
 this library calling
 @RefFunc{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    @RefSect{extras.disable_contract_compilation__macro_interface_,
            Disable Contract Compilation},
            @RefSect{tutorial.constructors, Constructors}
    */
    #define BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(...)
#elif !defined(BOOST_CONTRACT_NO_PRECONDITIONS) // Not NO_CONSTRUCTORS here.
    // constructor_precondition.hpp already #included at top.

#define BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(...) \
 boost::contract::constructor_precondition< __VA_ARGS__ >
#else
 #include <boost/preprocessor/tuple/eat.hpp>
 // constructor_precondition.hpp always #included at top of this file.

#define BOOST_CONTRACT_CONSTRUCTOR_PRECONDITION(...) \
 /* always use default ctor (i.e., do nothing) */ \
 boost::contract::constructor_precondition< __VA_ARGS__ >() \
 BOOST_PP_TUPLE_EAT(0)
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
    /**
    Program contracts that can be completely disabled at compile-time for
    destructors.
    
    This is used together with @RefMacro{BOOST_CONTRACT_POSTCONDITION},
    @RefMacro{BOOST_CONTRACT_EXCEPT}, and @RefMacro{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
    @RefSect{contract_programming_overview.destructor_calls, Destructor Calls}):

@code
    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.
        }
        
        ...
    };
    @endcode

For optimization, this can be omitted for destructors that do not have
    postconditions and exception guarantees, within classes that have no
    invariants.
    
    @c BOOST_CONTRACT_DESTRUCTOR(obj) expands to code equivalent to the
    following (note that no code is generated when
    @RefMacro{BOOST_CONTRACT_NO_DESTRUCTORS} is defined):
    
    @code
        #ifndef BOOST_CONTRACT_NO_DESTRUCTORS
            boost::contract::check internal_var =
                    boost::contract::destructor(obj)
        #endif
    @endcode

Where:
 
 @arg <c>obj</c> is the object @c this from the scope of the
 enclosing destructor declaring the contract.
 Destructors check all class invariants, including static and
 volatile invariants (see @RefSect{tutorial.class_invariants,
 Class Invariants} and
 @RefSect{extras.volatile_public_functions,
 Volatile Public Functions}).
 (This is a variadic macro parameter so it can contain commas not
 protected by round parenthesis.)
 @arg <c>internal_var</c> 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 @RefSect{extras.disable_contract_compilation__macro_interface_,
 Disable Contract Compilation},
 @RefSect{tutorial.destructors, Destructors}
 */
 #define BOOST_CONTRACT_DESTRUCTOR(...)
#elif !defined(BOOST_CONTRACT_NO_DESTRUCTORS)
 #include <boost/contract/destructor.hpp>
 #include <boost/contract/check.hpp>
 #include <boost/contract/detail/name.hpp>

#define BOOST_CONTRACT_DESTRUCTOR(...) \
        boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \
                boost::contract::destructor(__VA_ARGS__)
#else
    #define BOOST_CONTRACT_DESTRUCTOR(...) /* nothing */
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
    /**
    Program contracts that can be completely disabled at compile-time for
    (non-public) functions.
    
    This is used together with @RefMacro{BOOST_CONTRACT_PRECONDITION},
    @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT},
    and @RefMacro{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:
    
    @code
    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.
    }
    @endcode
    
    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.

@c BOOST_CONTRACT_FUNCTION() expands to code equivalent to the following
 (note that no code is generated when @RefMacro{BOOST_CONTRACT_NO_FUNCTIONS}
 is defined):
 
 @code
 #ifndef BOOST_CONTRACT_NO_FUNCTIONS
 boost::contract::check internal_var =
 boost::contract::function()
 #endif
 @endcode
 
 Where:
 
 @arg <c>internal_var</c> 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 @RefSect{extras.disable_contract_compilation__macro_interface_,
 Disable Contract Compilation},
 @RefSect{tutorial.non_member_functions, Non-Member Functions},
 @RefSect{advanced.private_and_protected_functions,
 Private and Protected Functions},
 @RefSect{advanced.lambdas__loops__code_blocks__and__constexpr__,
 Lambdas\, Loops\, Code Blocks}
 */
 #define BOOST_CONTRACT_FUNCTION()
#elif !defined(BOOST_CONTRACT_NO_FUNCTIONS)
 #include <boost/contract/function.hpp>
 #include <boost/contract/check.hpp>
 #include <boost/contract/detail/name.hpp>

#define BOOST_CONTRACT_FUNCTION() \
 boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \
 boost::contract::function()
#else
 #include <boost/preprocessor/facilities/empty.hpp>

#define BOOST_CONTRACT_FUNCTION() /* nothing */
#endif

#ifdef BOOST_CONTRACT_DETAIL_DOXYGEN
    /**
    Program contracts that can be completely disabled at compile-time for static
    public functions.
    
    This is used together with @RefMacro{BOOST_CONTRACT_PRECONDITION},
    @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT},
    and @RefMacro{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:

@code
    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.
        }
        
        ...
    };
    @endcode

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.
 
 @c BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(class_type) expands to code
 equivalent to the following (note that no code is generated when
 @RefMacro{BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS} is defined):
 
 @code
 #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
 boost::contract::check internal_var =
 boost::contract::public_function<class_type>()
 #endif
 @endcode
 
 Where:
 
 @arg <c>class_type</c> 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.)
 @arg <c>internal_var</c> 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 @RefSect{extras.disable_contract_compilation__macro_interface_,
 Disable Contract Compilation},
 @RefSect{tutorial.static_public_functions, Static Public Functions}
 */
 #define BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(...)

/**
    Program contracts that can be completely disabled at compile-time for
    non-static public functions that do not override.
    
    This is used together with @RefMacro{BOOST_CONTRACT_PRECONDITION},
    @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT},
    and @RefMacro{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:

@code
    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`).
        }
        
        ...
    };
    @endcode

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
    @RefMacro{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
    @RefMacro{BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS} is defined).

1\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION(obj)</c> expands to code
 equivalent to the following (for non-virtual public functions that are
 not static and do not override, returning void or not):

@code
 #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
 boost::contract::check internal_var =
 boost::contract::public_function(obj)
 #endif
 @endcode
 
 2\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION(v, obj)</c> expands to code
 equivalent to the following (for virtual public functions that do not
 override, returning void):

@code
 #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
 boost::contract::check internal_var =
 boost::contract::public_function(v, obj)
 #endif
 @endcode
 
 3\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION(v, r, obj)</c> expands to code
 equivalent to the following (for virtual public functions that do not
 override, not returning void):

@code
        #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
            boost::contract::check internal_var =
                    boost::contract::public_function(v, r, obj)
        #endif
    @endcode

Where (these are all variadic macro parameters so they can contain commas
    not protected by round parenthesis):

@arg <c>v</c> is the extra parameter of type
 @RefClass{boost::contract::virtual_}<c>*</c> and default value @c 0
 from the enclosing virtual public function declaring the contract.
 @arg <c>r</c> 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
 @c return statement.
 @arg <c>obj</c> is the object @c this from the scope of the
 enclosing public function declaring the contract.
 This object might be mutable, @c const, @c volatile, or
 <c>const volatile</c> depending on the cv-qualifier of the enclosing
 function (volatile public functions will check volatile class
 invariants, see @RefSect{extras.volatile_public_functions,
 Volatile Public Functions}).
 @arg <c>internal_var</c> 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 @RefSect{extras.disable_contract_compilation__macro_interface_,
 Disable Contract Compilation},
 @RefSect{tutorial.public_functions, Public Functions},
 @RefSect{tutorial.virtual_public_functions,
 Virtual Public Functions}
 */
 #define BOOST_CONTRACT_PUBLIC_FUNCTION(...)
 
 /**
 Program contracts that can be completely disabled at compile-time for
 public function overrides.
 
 This is used together with @RefMacro{BOOST_CONTRACT_PRECONDITION},
 @RefMacro{BOOST_CONTRACT_POSTCONDITION}, @RefMacro{BOOST_CONTRACT_EXCEPT},
 and @RefMacro{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):

@code
 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`).
        }
        
        ...
    };
    @endcode

Public function overrides should always use
    @RefMacro{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
    @RefMacro{BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS} is defined).

1\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_type)(v, f, obj,
 ...)</c> expands to code equivalent to the following (for public
 function overrides that return void):

@code
 #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
 boost::contract::check internal_var = boost::contract::
 public_function<override_type>(v, f, obj, ...)
 #endif
 @endcode
 
 2\. <c>BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(override_type)(v, r, f, obj,
 ...)</c> expands to code equivalent to the following (for public
 function overrides that do not return void):

@code
 #ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
 boost::contract::check internal_var = boost::contract::
 public_function<override_type>(v, r, f, obj, ...)
 #endif
 @endcode

Where (these are all variadic macro parameters so they can contain commas
    not protected by round parenthesis):

@arg <c>override_type</c> is the type
 <c>override_function-name</c> declared using the
 @RefMacro{BOOST_CONTRACT_OVERRIDE} or related macros.
 @arg <c>v</c> is the extra parameter of type
 @RefClass{boost::contract::virtual_}<c>*</c> and default value @c 0
 from the enclosing virtual public function declaring the contract.
 @arg <c>r</c> 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
 @c return statement.
 @arg <c>f</c> is a pointer to the enclosing public function
 override declaring the contract.
 @arg <c>obj</c> is the object @c this from the scope of the
 enclosing public function declaring the contract.
 This object might be mutable, @c const, @c volatile, or
 <c>const volatile</c> depending on the cv-qualifier of the enclosing
 function (volatile public functions will check volatile class
 invariants, see @RefSect{extras.volatile_public_functions,
 Volatile Public Functions}).
 @arg <c>...</c> 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 @c v.
 @arg <c>internal_var</c> 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 @RefSect{extras.disable_contract_compilation__macro_interface_,
 Disable Contract Compilation},
 @RefSect{tutorial.public_function_overrides__subcontracting_,
 Public Function Overrides}
 */
 #define BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(...)
#elif !defined(BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS)
 #include <boost/contract/public_function.hpp>
 #include <boost/contract/check.hpp>
 #include <boost/contract/detail/name.hpp>
 
 #define BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(...) \
 boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \
 boost::contract::public_function< __VA_ARGS__ >()

#define BOOST_CONTRACT_PUBLIC_FUNCTION(...) \
        boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \
                boost::contract::public_function(__VA_ARGS__)

#define BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(...) \
 boost::contract::check BOOST_CONTRACT_DETAIL_NAME2(c, __LINE__) = \
 boost::contract::public_function<__VA_ARGS__>
#else
 #include <boost/preprocessor/tuple/eat.hpp>
 
 #define BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(...) /* nothing */

#define BOOST_CONTRACT_PUBLIC_FUNCTION(...) /* nothing */
    
    #define BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(...) BOOST_PP_TUPLE_EAT(0)
#endif

#endif // #include guard

cmd: