Re: Released Contract Programming Library for C++

Hello all,

I have released Contract++ 0.4.0 on SourceForge (this library is being
considered for addition into Boost).

This library implements Contract Programming for the C++ programming
language (see the end of this email). In addition, the library
implements virtual specifiers (final, override, and new, see C++11),
concept checking, and named parameters.
This library is implemented for the C++03 standard and it does not
require C++11.

Documentation:
http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_4_0/doc/html/index.html

Source:
http://sourceforge.net/projects/contractpp/files/latest/download

Comments are welcome!

Thanks,
--Lorenzo

INTRODUCTION

Contract Programming is also known as Design by Contract(TM) and it
was first introduced by the Eiffel programming language.
All Contract Programming features of the Eiffel programming language
are supported by this library, among others:

* Support for preconditions, postconditions, class invariants, block
invariants, and loop variants.
* Subcontract derived classes (with support for pure virtual functions
and multiple inheritance).
* Access expression old values and function return value in
postconditions.
* Optional compilation and checking of preconditions, postconditions,
class invariants, block invariants, and loop variants.
* Customizable actions on contract assertion failure (terminate by
default but it can throw, exit, etc).

All features:
http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_4_0/doc/html/contract__/contract_programming_overview.html#contract__.contract_programming_overview.features

EXAMPLE

The example below shows how to use this library to program contracts
for the STL member function std::vector::push_back (in order to
illustrate subcontracting, the vector class inherits from the somewhat
arbitrary pushable base class).

#include<contract.hpp> // This library.
#include<boost/concept_check.hpp>
#include<vector>
#include "pushable.hpp" // Some base class.

CONTRACT_CLASS(
    template( typename T ) requires( boost::CopyConstructible<T> ) //
Concepts.
    class (vector) extends( public pushable<T> ) // Subcontracting.
) {
    CONTRACT_CLASS_INVARIANT_TPL(
        empty() == (size() == 0) // More class invariants here...
    )

    public: typedef typename std::vector<T>::size_type size_type;
    public: typedef typename std::vector<T>::const_reference
const_reference;

    CONTRACT_FUNCTION_TPL(
        public void (push_back) ( (T const&) value ) override
            precondition(
                size()< max_size() // More preconditions here...
            )
            postcondition(
                auto old_size = CONTRACT_OLDOF size(), // Old-of
values.
                size() == old_size + 1 // More postconditions here...
            )
    ) {
        vector_.push_back(value); // Original function body.
    }

    // Rest of class here (possibly with more contracts)...
    public: bool empty ( void ) const { return vector_.empty(); }
    public: size_type size ( void ) const { return vector_.size(); }
    public: size_type max_size ( void ) const { return
vector_.max_size(); }
    public: const_reference back ( void ) const { return
vector_.back(); }

    private: std::vector<T> vector_;
};