| Home | Libraries | People | FAQ | More

## Class template specify_precondition_old_postcondition_except

boost::contract::specify_precondition_old_postcondition_except — Allow to specify preconditions, old values copied at body, postconditions, and exception guarantees.

## Synopsis

    // In header: <boost/contract/core/specify.hpp>

    template<typename VirtualResult = void>
    class specify_precondition_old_postcondition_except {
    public:

      // public member functions
      ~specify_precondition_old_postcondition_except() noexcept(false);
      template<typename F>
        specify_old_postcondition_except< VirtualResult > precondition(F const &);
      template<typename F>
        specify_postcondition_except< VirtualResult > old(F const &);
      template<typename F> specify_except postcondition(F const &);
      template<typename F> specify_nothing except(F const &);
    };

## Description

Allow to specify functors this library will call to check preconditions, copy old values at body, check postconditions, and check exception guarantees. This object is internally constructed by the library when users specify contracts calling `boost::contract::function` and similar functions (that is why this class does not have a public constructor).

See Also: Preconditions, Old Values Copied at Body, Postconditions, Exception Guarantees

### Template Parameters

1.     typename VirtualResult = void

   Return type of the enclosing function declaring the contract if that is either a virtual or an overriding public function, otherwise this is always `void`. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.)

### `specify_precondition_old_postcondition_except` public member functions

1.     ~specify_precondition_old_postcondition_except() noexcept(false);

   Destruct this object.

   Throws: This is declared `noexcept(false)` since C++11 to allow users to program failure handlers that throw exceptions on contract assertion failures (not the default, see Throw on Failure).

2.     template<typename F>
         specify_old_postcondition_except< VirtualResult > precondition(F const & f);

   Allow to specify preconditions.

   Parameters: |
   `f` | Nullary functor called by this library to check preconditions `f()`. Assertions within this functor are usually programmed using ``BOOST_CONTRACT_ASSERT``, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling ``boost::contract::precondition_failure``). This functor should capture variables by (constant) value, or better by (constant) reference (to avoid extra copies).
   Returns: | After preconditions have been specified, the object returned by this function allows to optionally specify old values copied at body, postconditions, and exception guarantees.

3.     template<typename F>
         specify_postcondition_except< VirtualResult > old(F const & f);

   Allow to specify old values copied at body.

   It should often be sufficient to initialize old value pointers as soon as they are declared, without using this function (see Old Values Copied at Body).

   Parameters: |
   `f` | Nullary functor called by this library `f()` to assign old value copies just before the body is executed but after entry invariants (when they apply) and preconditions are checked. Old value pointers within this functor call are usually assigned using ``BOOST_CONTRACT_OLDOF``. Any exception thrown by a call to this functor will result in this library calling ``boost::contract::old_failure`` (because old values could not be copied to check postconditions and exception guarantees). This functor should capture old value pointers by references so they can be assigned (all other variables needed to evaluate old value expressions can be captured by (constant) value, or better by (constant) reference to avoid extra copies).
   Returns: | After old values copied at body have been specified, the object returned by this functions allows to optionally specify postconditions and exception guarantees.

4.     template<typename F> specify_except postcondition(F const & f);

   Allow to specify postconditions.

   Parameters: |
   `f` | Functor called by this library to check postconditions `f()` or `f(result)`. Assertions within this functor are usually programmed using ``BOOST_CONTRACT_ASSERT``, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling ``boost::contract::postcondition_failure``). This functor should capture variables by (constant) references (to access the values they will have at function exit). This functor must be a nullary functor `f()` if `VirtualResult` is `void`, otherwise it must be a unary functor `f(result)` accepting the return value `result` as a parameter of type `VirtualResult const&` (to avoid extra copies of the return value, or of type `VirtualResult` or `VirtualResult const` if extra copies of the return value are irrelevant).
   Returns: | After postconditions have been specified, the object returned by this function allows to optionally specify exception guarantees.

5.     template<typename F> specify_nothing except(F const & f);

   Allow to specify exception guarantees.

   Parameters: |
   `f` | Nullary functor called by this library to check exception guarantees `f()`. Assertions within this functor are usually programmed using ``BOOST_CONTRACT_ASSERT``, but any exception thrown by a call to this functor indicates a contract assertion failure (and will result in this library calling ``boost::contract::except_failure``). This functor should capture variables by (constant) references (to access the values they will have at function exit).
   Returns: | After exception guarantees have been specified, the object returned by this function does not allow to specify any additional contract.