Function template public_function

boost::contract::public_function — Program contracts for void public functions overrides (virtual or not).

Synopsis

// In header: <boost/contract/public_function.hpp>


template<typename Override, typename F, typename Class, typename... Args> 
  specify_precondition_old_postcondition_except 
  public_function(virtual_ * v, F f, Class * obj, Args &... args);

Description

This is used to specify preconditions, postconditions, exception guarantees, old value copies at body, and check class invariants for public function overrides (virtual or not) that return void:

class u
    #define BASES private boost::contract::constructor_precondition<u>, \
            public b, private w
    : BASES
{
    friend class boost::contract::access;

    typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
    #undef BASES

    void invariant() const { // Optional (as for static and volatile).
        BOOST_CONTRACT_ASSERT(...);
        ...
    }

    BOOST_CONTRACT_OVERRIDES(f)

public:
    // Override from `b::f`.
    void f(t_1 a_1, ..., t_n a_n, boost::contract::virtual_* v = 0) {
        boost::contract::old_ptr<old_type> old_var;
        boost::contract::check c = boost::contract::public_function<
                override_f>(v, &u::f, this, a_1, ..., a_n)
            .precondition([&] { // Optional.
                BOOST_CONTRACT_ASSERT(...);
                ...
            })
            .old([&] { // Optional.
                old_var = BOOST_CONTRACT_OLDOF(v, old_expr);
                ...
            })
            .postcondition([&] { // Optional.
                BOOST_CONTRACT_ASSERT(...);
                ...
            })
            .except([&] { // Optional.
                BOOST_CONTRACT_ASSERT(...);
                ...
            })
        ;

        ... // Function body.
    }
    
    ...
};

A public function override should always call boost::contract::public_function otherwise this library will not be able to correctly use it for subcontracting.

See Also:

Public Function Overrides

Parameters:

`args`	All arguments passed to the enclosing public function override declaring the contract (by reference and in the order they appear in the enclosing function declaration), but excluding the trailing argument `v`.
`f`	A pointer to the enclosing public function override declaring the contract.
`obj`	The object `this` from the scope of the enclosing public function override declaring the contract. This object might be mutable, `const`, `volatile`, or `const volatile` depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see Volatile Public Functions).
`v`	The trailing parameter of type `boost::contract::virtual_*` and default value `0` from the enclosing public function override.

Template Parameters:

`Args`	The types of all parameters passed to the enclosing public function override declaring the contract, but excluding the trailing parameter type `boost::contract::virtual_*`. On compilers that do not support variadic templates, this library internally implements this function using preprocessor meta-programming (in this case, the maximum number of supported arguments is defined by `BOOST_CONTRACT_MAX_ARGS`). (Usually these template parameters are automatically deduced by C++ and they do not need to be explicitly specified by programmers.)
`Class`	The type of the class containing the virtual public function declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.)
`F`	The function pointer type of the enclosing public function override declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers, but see Function Overloads.)
`Override`	The type `override_function-name` declared using the `BOOST_CONTRACT_OVERRIDE` or related macros. This template parameter must be explicitly specified (because there is no function argument from which it can be automatically deduced by C++).

Returns:

The result of this function must be explicitly assigned to a variable of type boost::contract::check declared locally just before the code of the public function body (otherwise this library will generate a run-time error, see BOOST_CONTRACT_ON_MISSING_CHECK_DECL).

Boost C++ Libraries