ray-cpp 2.54.0__py3-none-win_amd64.whl

ray/cpp/include/boost/contract_macro.hpp

@@ -0,0 +1,1409 @@
+
+#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><b>f</b></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><b>f</b></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><b>f</b></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><b>f</b></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><b>old_type</b></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><b>v</b></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><b>old_var</b></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><b>old_expr</b></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.
+        }
+
+        ...
+    };
+    @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_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><b>old_type</b></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><b>v</b></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><b>old_var</b></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><b>old_expr</b></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    <b>{ ... }</b> 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    <b>{ ... }</b> 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    <b>{ ... }</b> 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.)
+
+    @see    @RefSect{extras.disable_contract_compilation__macro_interface_,
+            Disable Contract Compilation},
+            @RefSect{tutorial.class_invariants, Class Invariants}
+    */
+    #define BOOST_CONTRACT_STATIC_INVARIANT(...)
+#elif !defined(BOOST_CONTRACT_NO_INVARIANTS)
+    #include <boost/contract/core/config.hpp>
+
+    #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><b>obj</b></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><b>internal_var</b></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<u>, \
+                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><b>class_type</b></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><b>f</b></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><b>obj</b></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><b>internal_var</b></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><b>internal_var</b></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><b>class_type</b></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><b>internal_var</b></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><b>v</b></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><b>r</b></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><b>obj</b></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><b>internal_var</b></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<u>, \
+                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><b>override_type</b></c> is the type
+            <c>override_<i>function-name</i></c> declared using the
+            @RefMacro{BOOST_CONTRACT_OVERRIDE} or related macros.
+    @arg    <c><b>v</b></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><b>r</b></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><b>f</b></c> is a pointer to the enclosing public function
+            override declaring the contract.
+    @arg    <c><b>obj</b></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><b>...</b></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><b>internal_var</b></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
+