Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r74384 - in sandbox/contract/libs/contract/doc/html2: . contract__
From: lorcaminiti_at_[hidden]
Date: 2011-09-15 11:10:46

Author: lcaminiti
Date: 2011-09-15 11:10:45 EDT (Thu, 15 Sep 2011)
New Revision: 74384
URL: http://svn.boost.org/trac/boost/changeset/74384

Log:
Upd with func-try-blocks.
Text files modified:
   sandbox/contract/libs/contract/doc/html2/contract__/examples.html | 398 +++++++++++++++++----------------------
   sandbox/contract/libs/contract/doc/html2/contract__/grammar.html | 98 +++++++++
   sandbox/contract/libs/contract/doc/html2/contract__/release_notes.html | 24 +
   sandbox/contract/libs/contract/doc/html2/index.html | 2
   4 files changed, 287 insertions(+), 235 deletions(-)

Modified: sandbox/contract/libs/contract/doc/html2/contract__/examples.html
==============================================================================
--- sandbox/contract/libs/contract/doc/html2/contract__/examples.html (original)
+++ sandbox/contract/libs/contract/doc/html2/contract__/examples.html 2011-09-15 11:10:45 EDT (Thu, 15 Sep 2011)
@@ -183,22 +183,13 @@


<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">#include <contract.hpp>
+#include <contract/trivial.hpp> // Contracts add not type requirements.
#include <boost/utility.hpp> // For boost::prior().
#include <boost/concept_check.hpp>
#include <iterator>
#include <vector>

-// Tools (forward declared, see actual declarations at the bottom).
-
-template< class Iter, class T >
-bool all_equals ( Iter first, Iter last, const T& val ) ;
-
-template< class Iter, class Size >
-bool equal_distance ( Iter first, Iter last, Size size ) ;
-
-// New vector interface (with contracts).
-
-CONTRACT_CLASS(
+CONTRACT_CLASS( // New vector interface (with contracts).
template( class T, class Alloc, default std::allocator<T> )
class (vector) // No base classes so no subcontracting for this example.
) {
@@ -240,13 +231,19 @@
 CONTRACT_CONSTRUCTOR_TPL(
 public explicit (vector) ( (size_type) count )
 initialize( vect_(count) )
- postcondition( size() == count, all_equals(begin(), end(), T()) )
+ postcondition(
+ size() == count,
+ contract::trivial::range(begin(), end()) == T()
+ )
 ) {}

 CONTRACT_CONSTRUCTOR_TPL(
 public (vector) ( (size_type) count, (const T&) val )
 initialize( vect_(count, val) )
- postcondition( size() == count, all_equals(begin(), end(), val) )
+ postcondition(
+ size() == count,
+ contract::trivial::range(begin(), end()) == val
+ )
 ) {}

 CONTRACT_CONSTRUCTOR_TPL(
@@ -254,16 +251,16 @@
 initialize( vect_(count, val, al) )
 postcondition(
 size() == count,
- all_equals(begin(), end(), val),
+ contract::trivial::range(begin(), end()) == val,
 al == get_allocator()
 )
 ) {}

- CONTRACT_CONSTRUCTOR_TPL(
- public template( class InIt ) requires( boost::InputIterator<InIt> ) // Concept.
+ CONTRACT_CONSTRUCTOR_TPL( // With concept requirements.
+ public template( class InIt ) requires( boost::InputIterator<InIt> )
 (vector) ( (InIt) first, (InIt) last )
 initialize( vect_(first, last) )
- postcondition( equal_distance(first, last, size()) )
+ postcondition( std::distance(first, last) == int(size()) )
 ) {}

 CONTRACT_CONSTRUCTOR_TPL(
@@ -271,7 +268,7 @@
 (vector) ( (InIt) first, (InIt) last, (const Alloc&) al )
 initialize( vect_(first, last, al) )
 postcondition(
- equal_distance(first, last, size()),
+ std::distance(first, last) == int(size()),
 al == get_allocator()
 )
 ) {}
@@ -279,15 +276,19 @@
 CONTRACT_CONSTRUCTOR_TPL(
 public (vector) ( (const vector&) right )
 initialize( vect_(right.vect_) )
- postcondition( right == *this )
+ postcondition(
+ using contract::trivial::range,
+ range(begin(), end()) == range(right.begin(), right.end())
+ )
 ) {}

- CONTRACT_FUNCTION_TPL( // Operator symbol followed by (arbitrary) name `copy`.
+ CONTRACT_FUNCTION_TPL( // Operator symbol and (arbitrary) name `copy`.
 public (vector&) operator(=)(copy) ( (const vector&) right )
 postcondition(
+ using contract::trivial::range,
 auto result = return,
- right == *this,
- result == *this
+ range(begin(), end()) == range(right.begin(), right.end()),
+ range(result.begin(), result.end()) == range(begin(), end())
 )
 ) {
 return vect_ = right.vect_;
@@ -298,7 +299,7 @@
 ) {}

 CONTRACT_FUNCTION_TPL(
- // No required wrapping parenthesis for keyword types like `void`, `bool`, etc.
+ // No required wrapping parenthesis for keyword types `void`, `bool`, etc.
 public void (reserve) ( (size_type) count )
 precondition( count < max_size() )
 postcondition( capacity() >= count )
@@ -371,10 +372,10 @@
 CONTRACT_FUNCTION_TPL(
 public void (resize) ( (size_type) newsize )
 postcondition(
- auto old_size = CONTRACT_OLDOF size(), // Old value (as before body).
+ auto old_size = CONTRACT_OLDOF size(), // Old value (before body).
 size() == newsize,
 if(newsize > old_size) ( // Version 1: Within an `if`.
- all_equals(begin() + old_size, end(), T())
+ contract::trivial::range(begin() + old_size, end()) == T()
 ) // Omitted optional `else( ... )`.
 )
 ) {
@@ -386,8 +387,9 @@
 postcondition(
 (size_type) old_size = CONTRACT_OLDOF size(), // Specify old type.
 size() == newsize,
- newsize > old_size ? // Version 2: With ternary operator.
- all_equals(begin() + old_size, end(), val) : true
+ newsize > old_size // Version 2: With ternary operator.
+ ? contract::trivial::range(begin() + old_size, end()) == val
+ : true
 )
 ) {
 vect_.resize(newsize, val);
@@ -480,9 +482,10 @@
 public void (push_back) ( (const T&) val )
 precondition( size() < max_size() )
 postcondition(
+ using contract::trivial::operator==,
 auto old_size = CONTRACT_OLDOF size(),
 auto old_capacity = CONTRACT_OLDOF capacity(),
- back() == val,
+ back() == val, // Trivial == if not EqualityComparable<T>.
 size() == old_size + 1,
 capacity() >= old_capacity
 )
@@ -504,8 +507,11 @@
 CONTRACT_FUNCTION_TPL(
 public template( class InIt ) requires( boost::InputIterator<InIt> )
 void (assign) ( (InIt) first, (InIt) last )
- // Precondition: [first, last) is not a sub-range of [begin(), end()).
- postcondition( equal_distance(first, last, size()) )
+ precondition(
+ using contract::trivial::range,
+ range(first, last).contained(range(begin(), end())) == false
+ )
+ postcondition( std::distance(first, last) == int(size()) )
 ) {
 vect_.assign(first, last);
 }
@@ -513,7 +519,7 @@
 CONTRACT_FUNCTION_TPL(
 public void (assign) ( (size_type) count, (const T&) val )
 precondition( count <= max_size() )
- postcondition( all_equals(begin(), end(), val) )
+ postcondition( contract::trivial::range(begin(), end()) == val )
 ) {
 vect_.assign(count, val);
 }
@@ -522,12 +528,17 @@
 public (iterator) (insert) ( (iterator) pos, (const T&) val )
 precondition( size() < max_size() )
 postcondition(
+ using contract::trivial::operator==,
 auto result = return,
 auto old_size = CONTRACT_OLDOF size(),
- val == *result,
- size() == old_size + 1
- // if(capacity() > oldof capacity()): [begin(), end()] invalid
- // else: [pos, end()) invalid
+ auto old_capacity = CONTRACT_OLDOF capacity(),
+ val == *result, // Trivial == if not EqualityComparable<T>.
+ size() == old_size + 1,
+ if(capacity() > old_capacity) (
+ contract::trivial::range(begin(), end()).invalid()
+ ) else (
+ contract::trivial::range(pos, end()).invalid()
+ )
 )
 ) {
 return vect_.insert(pos, val);
@@ -537,16 +548,20 @@
 public void (insert) ( (iterator) pos, (size_type) count, (const T&) val )
 precondition( size() + count < max_size() )
 postcondition(
+ using contract::trivial::range,
+ using boost::prior,
 auto old_size = CONTRACT_OLDOF size(),
 auto old_capacity = CONTRACT_OLDOF capacity(),
 auto old_pos = CONTRACT_OLDOF pos,
 size() == old_size + count,
 capacity() >= old_capacity,
 if(capacity() == old_capacity) (
- all_equals(boost::prior(old_pos),
- boost::prior(old_pos) + count, val)
- // [pos, end()) invalid
- ) // else: [begin(), end()) invalid
+ range(prior(old_pos),
+ prior(old_pos) + count) == val,
+ range(const_iterator(pos), end()).invalid()
+ ) else (
+ range(begin(), end()).invalid()
+ )
 )
 ) {
 vect_.insert(pos, count, val);
@@ -556,7 +571,8 @@
 public template( class InIt )
 void (insert) ( (iterator) pos, (InIt) first, (InIt) last )
 precondition(
- // [first, last) not a sub-range of [begin(), end())
+ using contract::trivial::range,
+ range(first, last).contained(range(begin(), end())) == false,
 size() + std::distance(first, last) < max_size()
 )
 postcondition(
@@ -579,8 +595,8 @@
 auto result = return,
 auto old_size = CONTRACT_OLDOF size(),
 size() == old_size = 1,
- if(empty()) ( result == end() )
- // [pos, end()) invalid
+ if(empty()) ( result == end() ),
+ contract::trivial::range(pos, end()).invalid()
 )
 ) {
 return vect_.erase();
@@ -593,8 +609,8 @@
 auto result = return,
 auto old_size = CONTRACT_OLDOF size(),
 size() == old_size - std::distance(first, last),
- if(empty()) ( result == end() )
- // [first, last) invalid
+ if(empty()) ( result == end() ),
+ contract::trivial::range(first, last).invalid()
 )
 ) {
 return vect_.erase(first, last);
@@ -610,10 +626,12 @@
 CONTRACT_FUNCTION_TPL(
 public void (swap) ( (vector&) right )
 postcondition(
+ using contract::trivial::range,
 auto old_self = CONTRACT_OLDOF *this,
 auto old_right = CONTRACT_OLDOF right,
- old_self == right,
- old_right == *this
+ range(right.begin(), right.end()) ==
+ range(old_self.begin(), old_self.end()),
+ range(begin(), end()) == range(old_right.begin(), old_right.end())
 )
 ) {
 vect_.swap(right);
@@ -622,49 +640,6 @@
private:
 std::vector<T, Alloc> vect_;
};
-
-CONTRACT_FUNCTION_TPL(
-template( class Iter, class T )
- requires(
- boost::ForwardIterator<Iter>,
- boost::EqualityComparable<T> // For simplicity, assume T comparable.
- )
-bool (all_equals) ( (Iter) first, (Iter) last, (const T&) val )
-) {
- for(Iter i = first; i < last; ++i) if(*i != val) return false;
- return true;
-}
-
-CONTRACT_FUNCTION_TPL(
-template( class Iter, class Size )
- requires(
- // Could use internal tagging mechanism to pass even input iterators.
- boost::ForwardIterator<Iter>,
- // IDENTITY_TYPE to handle unwrapped commas within macro parameters.
- typename CONTRACT_IDENTITY_TYPE((boost::Convertible<Size, int>))
- )
-bool (equal_distance) ( (Iter) first, (Iter) last, (Size) size )
-) {
- return int(size) == std::distance(first, last);
-}
-
-CONTRACT_FUNCTION_TPL(
-template( class T ) requires( boost::EqualityComparable<T> )
-bool operator(==)(equal) ( (const vector<T>&) left, (const vector<T>&) right )
- postcondition(
- auto result = return,
- if(result) (
- left.size() == right.size()
- // left and right values are all equal to each other.
- )
- )
-) {
- if(left.size() != right.size()) return false;
- for(typename vector<T>::const_iterator
- l = left.begin(), r = right.begin(); l != left.end(); ++l, ++r)
- if(*l != *r) return false;
- return true;
-}
</pre>

 
@@ -679,16 +654,7 @@
#include <iterator>
#include <vector>

-
-
-template< class Iter, class T >
-bool all_equals ( Iter first, Iter last, const T& val ) ;
-
-template< class Iter, class Size >
-bool equal_distance ( Iter first, Iter last, Size size ) ;
-
-
-
+// For simplicity, assume EqualityComparable<T> and all_equal defined.

template< class T, class Alloc = std::allocator<T> >
class vector
@@ -731,13 +697,19 @@

 public: explicit vector ( size_type count )
 : vect_(count)
- postcondition { size() == count; all_equals(begin(), end(), T()); }
+ postcondition {
+ size() == count;
+ all_equals(begin(), end(), T());
+ }
 {}

 public: vector ( size_type count, const T& val )
 : vect_(count, val)
- postcondition { size() == count; all_equals(begin(), end(), val); }
+ postcondition {
+ size() == count;
+ all_equals(begin(), end(), val);
+ }
 {}

@@ -754,7 +726,7 @@
 public: template< class InIt > requires std::InputIterator<InIt>
 vector ( InIt first, InIt last )
 : vect_(first, last)
- postcondition { equal_distance(first, last, size()); }
+ postcondition { std::distance(first, last) == int(size()); }
 {}

@@ -762,7 +734,7 @@
 vector ( InIt first, InIt last, const Alloc& al )
 : vect_(first, last, al)
 postcondition {
- equal_distance(first, last, size());
+ std::distance(first, last) == int(size());
 al == get_allocator();
 }
 {}
@@ -770,13 +742,17 @@

 public: vector ( const vector& right )
 : vect_(right.vect_)
- postcondition { right == *this; }
+ postcondition {
+
+ right == *this;
+ }
 {}

 public: vector& operator= ( const vector& right )
 postcondition(result) {

+
 right == *this;
 result == *this;
 }
@@ -877,8 +853,9 @@
 postcondition {

 size() == newsize;
- newsize > oldof size() ?
- all_equals(begin() + oldof size(), end(), val) : true;
+ newsize > oldof size()
+ ? all_equals(begin() + oldof size(), end(), val)
+ : true;
 }
 {
 vect_.resize(newsize, val);
@@ -973,6 +950,7 @@
 postcondition {

+
 back() == val;
 size() == oldof size() + 1;
 capacity() >= oldof capacity()
@@ -995,8 +973,11 @@

 public: template< class InIt > requires std::InputIterator<InIt>
 void assign ( InIt first, InIt last )
-
- postcondition { equal_distance(first, last, size()); }
+ precondition {
+
+ // Range [first, last) is not contained in [begin(), end()).
+ }
+ postcondition { std::distance(first, last) == int(size()); }
 {
 vect_.assign(first, last);
 }
@@ -1015,10 +996,15 @@
 postcondition(result) {

+
+
 val == *result;
 size() == oldof size() + 1;
-
-
+ if(capacity() > oldof capacity() {
+ // Range [begin(), end()) is invalid.
+ } else {
+ // Range [pos, end()) is invalid.
+ }
 }
 {
 return vect_.insert(pos, val);
@@ -1031,12 +1017,16 @@

+
+
 size() == oldof size() + count;
 capacity() >= oldof capacity();
 if(capacity() == oldof capacity()) {
 all_equals(boost::prior(oldof pos),
 boost::prior(oldof pos) + count, val);
-
+ // Range [pos, end()) is invalid.
+ } else {
+ // Range [begin(), end()) is invalid.
 }
 }
 {
@@ -1048,6 +1038,7 @@
 void insert ( iterator pos, InIt first, InIt last )
 precondition {

+ // Range [first, last) is not contained in [begin(), end()).
 size() + std::distance(first, last) < max_size();
 }
 postcondition {
@@ -1071,7 +1062,7 @@

 size() == oldod size() = 1;
 if(empty()) result == end();
-
+ // Range [pos, end()) is invalid.
 }
 {
 return vect_.erase();
@@ -1085,7 +1076,7 @@

 size() == oldof size() - std::distance(first, last);
 if(empty()) result == end();
-
+ // Range [first, last) is invalid.
 }
 {
 return vect_.erase(first, last);
@@ -1102,9 +1093,11 @@
 public: void swap ( vector& right )
 postcondition {

-
- oldof *this == right;
- oldof right == *this;
+
+
+ right == oldof *this;
+
+ *this == oldof right;
 }
 {
 vect_.swap(right);
@@ -1113,49 +1106,6 @@
private:
 std::vector<T, Alloc> vect_;
};
-
-
-template< class Iter, class T >
- requires
- boost::ForwardIterator<Iter>,
- boost::EqualityComparable<T>
-
-bool all_equals ( Iter first, Iter last, const T& val )
-{
- for(Iter i = first; i < last; ++i) if(*i != val) return false;
- return true;
-}
-
-
-template< class Iter, class Size >
- requires
-
- boost::ForwardIterator<Iter>,
-
- typename CONTRACT_IDENTITY_TYPE((boost::Convertible<Size, int>))
-
-bool equal_distance ( Iter first, Iter last, Size size )
-{
- return int(size) == std::distance(first, last);
-}
-
-
-template< class T > requires boost::EqualityComparable<T>
-bool operator== ( const vector<T>& left, const vector<T>& right )
- postcondition(result) {
-
- if(result) {
- left.size() == right.size();
-
- }
- }
-{
- if(left.size() != right.size()) return false;
- for(typename vector<T>::const_iterator
- l = left.begin(), r = right.begin(); l != left.end(); ++l, ++r)
- if(*l != *r) return false;
- return true;
-}
</pre>

 
@@ -1398,6 +1348,7 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/trivial.hpp>
#include <boost/concept_check.hpp>

template< typename T >
@@ -1412,15 +1363,13 @@
};

CONTRACT_FUNCTION(
-template( typename T )
- requires(
- Addable<T>
-#ifndef CONTRACT_CONFIG_NO_POSTCONDITIONS // Equality only for postconditions.
- , boost::EqualityComparable<T>
-#endif
- )
+template( typename T ) requires( Addable<T> )
(T) (add) ( (T) x, (T) y )
- postcondition( auto result = return, result == x + y )
+ postcondition(
+ using contract::trivial::operator==,
+ auto result = return,
+ result == x + y // Trivial == if T not EqualityComparable.
+ )
) {
 return x + y;
}
@@ -1437,6 +1386,7 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/trivial.hpp>
#include <boost/mpl/bool.hpp>
#include <vector>
#include <list>
@@ -1449,7 +1399,7 @@
 std::input_iterator_tag )
{
 CONTRACT_LOOP( while(n--) ) {
- CONTRACT_LOOP_VARIANT( const( n ) n )
+ CONTRACT_LOOP_VARIANT_TPL( n )
 ++i;
 }
}
@@ -1460,7 +1410,7 @@
{
 if(n >= 0) {
 CONTRACT_LOOP( while(n--) ) {
- CONTRACT_LOOP_VARIANT( const( n ) n )
+ CONTRACT_LOOP_VARIANT_TPL( n )
 ++i;
 }
 } else {
@@ -1468,7 +1418,7 @@
 Distance n_max = n;
#endif
 CONTRACT_LOOP( while(n++) ) {
- CONTRACT_LOOP_VARIANT( const( n_max, n ) n_max - n )
+ CONTRACT_LOOP_VARIANT_TPL( n_max - n )
 --i;
 }
 }
@@ -1492,7 +1442,7 @@
template( typename InputIterator, typename Distance )
void (myadvance) ( (InputIterator&) i, (Distance) n )
 precondition(
- // Precondition: All iterators in [i, i + n] non-singular.
+ contract::trivial::range(i, n + 1).nonsingular(), // Range [i, i + n].
 if(is_input_iterator<typename std::iterator_traits<InputIterator>::
 iterator_category>::value) (
 n > 0 // if input iterator, n positive
@@ -1503,8 +1453,8 @@
 std::distance(old_i, i) == n // iterator advanced of n
 )
) {
- aux::myadvance_dispatch(i, n, std::iterator_traits<InputIterator>::
- iterator_category());
+ aux::myadvance_dispatch(i, n, typename
+ std::iterator_traits<InputIterator>:: iterator_category());
}
</pre>

@@ -1519,18 +1469,19 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/trivial.hpp>
#include <boost/concept_check.hpp>

CONTRACT_FUNCTION(
template( typename Iter )
 requires(
 boost::InputIterator<Iter>,
- boost::EqualityComparable<typename
+ boost::EqualityComparable<typename // Equality needed to find value.
 boost::InputIterator<Iter>::value_type>
 )
(Iter) (myfind) ( (Iter) first, (Iter) last,
 (typename boost::InputIterator<Iter>::value_type const&) value )
- precondition( first <= last )
+ precondition( contract::trivial::range(first, last).valid() )
 postcondition(
 auto result = return,
 if(result != last) (
@@ -1539,7 +1490,9 @@
 )
) {
 CONTRACT_LOOP( while(first != last && *first != value) ) {
- CONTRACT_LOOP_VARIANT( const( first, last ) std::distance(first, last) )
+ /** @todo I get a GCC internal error (on Cygwin) if I use const-expr here... why? Can I work around it? */
+ CONTRACT_LOOP_VARIANT_TPL( const( first, last )
+ std::distance(first, last) )
 ++first;
 }
 return first;
@@ -1557,6 +1510,7 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/trivial.hpp>
#include <boost/concept_check.hpp>

// Use importance ordering to specify assertion computational complexity.
@@ -1568,12 +1522,10 @@
 requires(
 typename CONTRACT_IDENTITY_TYPE((
 boost::UnaryFunction<UnaryOp, Result, Arg0> ))
-#ifndef CONTRACT_CONFIG_NO_POSTCONDITIONS // Equality only for postconditions.
- , boost::EqualityComparable<Result>
-#endif
 )
(Result) (apply) ( (UnaryOp) op, (Arg0) arg0, (Result&) result )
 postcondition(
+ using contract::trivial::operator==, // Trivial == is Result hasn't ==.
 auto return_value = return,
 result == op(arg0), importance O_BODY,
 return_value == result
@@ -1585,14 +1537,12 @@
CONTRACT_FUNCTION( // Overload to invoke binary functors.
template( typename Result, typename Arg0, typename Arg1, typename BinaryOp )
 requires(
- typename CONTRACT_INDETITY_TYPE((
+ typename CONTRACT_IDENTITY_TYPE((
 boost::BinaryFunction<BinaryOp, Result, Arg0, Arg1> ))
-#ifndef CONTRACT_CONFIG_NO_POSTCONDITIONS // Equality only for postconditions.
- , boost::EqualityComparable<Result>
-#endif
 )
(Result) (apply) ( (BinaryOp) op, (Arg0) arg0, (Arg1) arg1, (Result&) result )
 postcondition(
+ using contract::trivial::operator==, // Avoid == requirement on Result.
 auto return_value = return,
 result == op(arg0, arg1), importance O_BODY,
 return_value == result
@@ -1613,24 +1563,26 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/trivial.hpp>
#include <boost/concept_check.hpp>

CONTRACT_FUNCTION(
template( typename Iter, typename Func )
 requires(
- boost::InputIterator<Iter>
- typename CONTRACT_INDENTITY_TYPE(( boost::UnaryFunction<Func, void,
+ boost::InputIterator<Iter>,
+ typename CONTRACT_IDENTITY_TYPE(( boost::UnaryFunction<Func, void,
 typename boost::InputIterator<Iter>::value_type> ))
-#ifndef CONTRACT_CONFIG_NO_POSTCONDITIONS // Equality only for postconditions.
- , boost::EqualityComparable<Func>
-#endif
 )
(Func) (my_for_each) ( (Iter) first, (Iter) last, (Func) func )
- precondition( first <= last )
- postcondition( auto result = return, result == func )
+ precondition( contract::trivial::range(first, last).valid() )
+ postcondition(
+ using contract::trivial::operator==,
+ auto result = return,
+ result == func // Trivial == if not EqualityComparable<Func>.
+ )
) {
 CONTRACT_LOOP( while(first < last) ) { // OK: Iter is InputIterator.
- CONTRACT_LOOP_VARIANT( const( first, last ) std::distance(first, last) )
+ CONTRACT_LOOP_VARIANT_TPL( std::distance(first, last) )
 func(*first); // OK: func is UnaryFunction.
 ++first; // OK: Iter is InputIterator.
 }
@@ -1648,8 +1600,9 @@



-<pre class="programlisting">#define CONTRACT_CONFIG_FUNCTION_ARITY_MAX 6 // Support 5 function parameters.
+<pre class="programlisting">#define CONTRACT_CONFIG_FUNCTION_ARITY_MAX 6 // Up 5 function parameters.
#include <contract.hpp>
+#include <contract/trivial.hpp>
#include <boost/concept_check.hpp>
#include <algorithm>

@@ -1664,15 +1617,15 @@
 typename boost::InputIterator<InIter1>::value_type,
 typename boost::InputIterator<InIter1>::value_type,
 typename boost::InputIterator<InIter2>::value_type> ))
-#ifndef CONTRACT_CONFIG_NO_POSTCONDITIONS // Equality only for postcondition
- , boost::EqualityComparable<typename
- boost::InputIterator<InIter1>::value_type>
-#endif
 )
(OutIter) (mytransform) ( (InIter1) first1, (InIter1) last1, (InIter2) first2,
 (OutIter) result, (BinOp) op )
- precondition( first1 <= last1 )
- postcondition( auto return_value = return, return_value == result )
+ precondition( contract::trivial::range(first1, last1).valid() )
+ postcondition(
+ using contract::trivial::operator==,
+ auto return_value = return,
+ return_value == result // Trivial == if InIter1::value_type has no ==.
+ )
) {
 return std::transform(first1, last1, first2, result, op);
}
@@ -1689,6 +1642,7 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/trivial.hpp>
#include <boost/concept_check.hpp>

CONTRACT_FUNCTION(
@@ -1702,13 +1656,12 @@
(typename boost::InputIterator<Iter>::difference_type) (mycount) (
 (Iter) first, (Iter) last,
 (typename boost::InputIterator<Iter>::value_type const&) value )
- // Precondition: [first, last) is valid range.
- precondition( first <= last )
+ precondition( contract::trivial::range(first, last).valid() )
 postcondition( auto result = return, result >= 0 )
) {
 typename boost::InputIterator<Iter>::difference_type result = 0;
 CONTRACT_LOOP( while(first != last) ) { // OK: Iter is equality comparable.
- CONTRACT_LOOP_VARIANT( const( first, last) std::distance(first, last) )
+ CONTRACT_LOOP_VARIANT_TPL( std::distance(first, last) )
 if(*first == value) // OK: Value is equality comparable.
 ++result;
 ++first; // OK: Iterator is input iterator.
@@ -1801,6 +1754,7 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/trivial.hpp>
#include <boost/concept_check.hpp>

CONTRACT_FUNCTION(
@@ -1808,15 +1762,15 @@
 requires(
 boost::InputIterator<Iter>,
 boost::CopyConstructible<typename
- boost::InputIterator<Iter>::value_type>,
-#ifndef CONTRACT_CONFIG_NO_POSTCONDITIONS // Equality only for postconditions.
- boost::EqualityComparable<typename
 boost::InputIterator<Iter>::value_type>
-#endif
 )
(typename boost::InputIterator<Iter>::value_type) (deref) ( (Iter) i )
- // Precondition: i is non-singular.
- postcondition( auto result = return, result == *i )
+ precondition( contract::trivial::singular(i) == false )
+ postcondition(
+ using contract::trivial::operator==,
+ auto result = return,
+ result == *i // Trivial == if Iter::value_type not EqualityComparable.
+ )
) {
 return *i;
}
@@ -1833,20 +1787,16 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/trivial.hpp>
#include <boost/concept_check.hpp>

CONTRACT_FUNCTION(
-template( typename T )
- requires(
- boost::LessThanComparable<T>
-#ifndef CONTRACT_CONFIG_NO_POSTCONDITIONS // Equality only for postconditions.
- , boost::EqualityComparable<T>
-#endif
- )
+template( typename T ) requires( boost::LessThanComparable<T> )
(T const&) (min) ( (T const&) x, (T const&) y )
 postcondition(
+ using contract::trivial::operator==,
 auto result = return,
- x < y ? result == x : result == y // Need both `<` and `==`.
+ x < y ? result == x : result == y // Trivial == if T has no ==.
 )
) {
 return x < y ? x : y; // OK: T is less than comparable `<`.
@@ -3173,12 +3123,12 @@
 }

private:
+ // Contract helpers.

- /** @todo make this static */
- CONTRACT_FUNCTION_TPL( // Postcondition helper.
- private bool (all_equal) ( (std::vector<T> const&) left,
+ CONTRACT_FUNCTION_TPL(
+ private static bool (all_equal) ( (std::vector<T> const&) left,
 (std::vector<T> const&) right, size_t offset, default 0
- ) const
+ )
 precondition( right.size() == left.size() + offset ) // correct offset
 ) {
 for(size_t i = offset; i < right.size(); ++i)
@@ -3471,10 +3421,9 @@
private:
 // Contract helpers.

- /** @todo make these static */
 CONTRACT_FUNCTION(
- private bool (all_observers_valid) (
- (std::list<observer const*> const&) observers ) const
+ private static bool (all_observers_valid) (
+ (std::list<observer const*> const&) observers )
 ) {
 for(std::list<observer const*>::const_iterator
 i = observers.begin(); i != observers.end(); ++i) {
@@ -4439,9 +4388,10 @@
 }

private:
- /** @todo make this static */
 CONTRACT_FUNCTION(
- private int (days_in) ( int month ) const
+ private static int (days_in) ( int month )
+ precondition( month >= 1, month <= 12 )
+ postcondition( auto result = return, result >= 1, result <= 31 )
 ) {
 return 31; // For simplicity, assume all months have 31 days.
 }

Modified: sandbox/contract/libs/contract/doc/html2/contract__/grammar.html
==============================================================================
--- sandbox/contract/libs/contract/doc/html2/contract__/grammar.html (original)
+++ sandbox/contract/libs/contract/doc/html2/contract__/grammar.html 2011-09-15 11:10:45 EDT (Thu, 15 Sep 2011)
@@ -41,6 +41,7 @@
 and Operator Names</a></dt>
<dt><a href="grammar.html#contract__.grammar.exception_specifications">Exception
 Specifications</a></dt>
+<dt>Member Initializers</dt>
<dt>Function Parameters</dt>
<dt><a href="grammar.html#contract__.grammar.result_and_old_of_declarations">Result
 and Old-Of Declarations</a></dt>
@@ -227,6 +228,11 @@
 zero or more times.
 </li>
<li class="listitem">
+ <code class="computeroutput">tokens+</code>
+ indicates <code class="computeroutput">tokens</code> repeated
+ one or more times.
+ </li>
+<li class="listitem">
 Terminals are indicated in bold <code class="literal">symbol</code>.
 </li>
<li class="listitem">
@@ -364,9 +370,9 @@
 [type] function-name ( [function-params] )
 [const] [volatile] [override | new] [final]
 [throw( [expections] )]
- [initialize( member-initializer, ... )]
 [precondition( assertion, ... )]
 [postcondition( result-oldof-assertions )]
+ [member-initializers]
</pre>
</div>
<div class="section">
@@ -439,7 +445,95 @@

 The keyword <code class="computeroutput">void</code> is used for
 no-throw <code class="computeroutput">throw(
- void )</code>.
+ void )</code>
+ (instead of <code class="computeroutput">throw()</code>).
+ 
+
+ Exception specifications apply to the entire function call so to exceptions
+ thrown by the body but also to exceptions thrown by the contract checking
+ code (if the contract broken handlers are redefined to throw) and to exceptions
+ thrown by this library implementation code (in case the library runs out
+ of resources, encounters an internal error, etc):
+ 
+<pre class="programlisting">CONTRACT_FUNCTION(
+int (f) ( int x ) throw( void ) // The entire function call (body and contracts) do not throw.
+) ;
+</pre>
+
+ If exception specifications are instead programmed just outside the macros
+ and before the body definition then they only apply to exceptions thrown
+ by the body and not to exceptions thrown by the contract checking and implementation
+ code:
+ 
+<pre class="programlisting">CONTRACT_FUNCTION(
+int (f) ( int x )
+) throw( ) ; // Only the body does not throw (contracts might still throw).
+</pre>
+
+ In both cases the exception specifications are part of the function declaration
+ so they need to be repeated in the body function signature when the body
+ is defined separately from the function declaration like in the example above:
+ 
+<pre class="programlisting">int CONTRACT_FREE_BODY(f) ( int x ) throw( ) { ... } // Body definition for both function declarations above.
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="contract__.grammar.member_initializers"></a><a class="link" href="grammar.html#contract__.grammar.member_initializers" title="Member Initializers">Member Initializers</a>
+</h3></div></div></div>
+<pre class="programlisting">member-initializers:
+ [try] initialize( member-initializer, ... )
+ {catch(exception-decl) ( statements )}*
+</pre>
+
+ As indicated by the above syntax, it is possible to wrap constructor member
+ initializers within a function-try-block:
+ 
+<pre class="programlisting">struct vector_error { ... };
+
+CONTRACT_CONSTRUCTOR(
+explicit (vector) ( int count )
+ precondition( count >= 0 )
+ postcondition( size() == count )
+
+ try initialize( ptr_(new T[count]) )
+ catch(std::bad_alloc& ex) (
+ std::cerr << "not enough memory for " << count << " elements: " << ex.what() << std::endl;
+ throw vector_error(1);
+ ) catch(std::exception& ex) (
+ std::cerr << "error for " << count << " elements: " << ex.what() << std::endl;
+ throw vector_error(2);
+ ) catch(...) (
+ std::cerr << "unknown error for " << count << " elements" << std::endl;
+ throw vector_error(3);
+ )
+) { // Above function-try-block only applies to exceptions thrown by the body (and not by the contracts).
+ ...
+}
+</pre>
+
+ For functions other than constructors, function-try-blocks are programmed
+ outside the macros and around the body definition as usual:
+ 
+<pre class="programlisting">CONTRACT_FUNCTION(
+float (sqrt) ( float x )
+ precondition( x >= 0 )
+ postcondition( auto result = return, x == result * result )
+) try { // This function-try-block only applies to exceptions thrown by the body (and not by the contracts).
+ return x * x;
+} catch(std::exceptions& ex) {
+ std::cerr << "error for " << x << ": " << ex.what() << std::endl;
+ return -1.0;
+} catch(...) {
+ std::cerr << "unknown error for " << x << std::endl;
+ return -2.0;
+}
+</pre>
+
+ As specified by <a class="link" href="bibliography.html" title="Bibliography">[N1962]</a>, function-try-blocks
+ always apply to exceptions only thrown by the body and not by the contract
+ code (either in case the contract broken handlers are redefined to throw
+ or if this library implementation code throws because of an internal error).
 
</div>
<div class="section">

Modified: sandbox/contract/libs/contract/doc/html2/contract__/release_notes.html
==============================================================================
--- sandbox/contract/libs/contract/doc/html2/contract__/release_notes.html (original)
+++ sandbox/contract/libs/contract/doc/html2/contract__/release_notes.html 2011-09-15 11:10:45 EDT (Thu, 15 Sep 2011)
@@ -35,26 +35,34 @@
 
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
- Include all necessary headers for all files.
+ Allows const( [(type_)] var, ... ) with optional (type_) for const assertions,
+ select-assertion if-conditions, and loop variants.
 </li>
<li class="listitem">
- Program concept checking for functions (not just class).
+ There were several GCC internal compiler errors when using const-assertions
+ in N2081 examples... Why? Can I work around these errors?
 </li>
<li class="listitem">
- Fix static member function contract (see some examples that fails).
+ Add support for exception spec. Can I support C++0x-like <code class="computeroutput">notrhow</code>? Can I can support function-try-blocks?
+ http://msdn.microsoft.com/en-us/library/e9etx778%28v=vs.71%29.aspx http://www.gotw.ca/gotw/066.htm
 </li>
<li class="listitem">
- Implement named parameters.
+ Include all necessary headers for all files.
 </li>
<li class="listitem">
- Allows const( [(type_)] var, ... ) with optional (type_) for const assertions,
- select-assertion if-conditions, and loop variants.
+ Replace all PP_NOT with PP_COMPL when no bool conversion is needed.
 </li>
<li class="listitem">
- Add support for exception spec.
+ Also allow typedefs within assertions-- anything else?
 </li>
<li class="listitem">
- Replace all PP_NOT with PP_COMPL when no bool conversion is needed.
+ Implement named parameters.
+ </li>
+<li class="listitem">
+ Verify that member initializers are part of constructor definition and
+ if so move <code class="computeroutput">initialize( ... )</code> to be the very last element in the syntax
+ (after pre and post). Instead, I think exception specs are part of the
+ declaration -- verify that -- so it's OK if they appear before pre/post.
 </li>
</ol></div>
</div>

Modified: sandbox/contract/libs/contract/doc/html2/index.html
==============================================================================
--- sandbox/contract/libs/contract/doc/html2/index.html (original)
+++ sandbox/contract/libs/contract/doc/html2/index.html 2011-09-15 11:10:45 EDT (Thu, 15 Sep 2011)
@@ -55,7 +55,7 @@
</h2></div></div></div></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: September 04, 2011 at 17:34:44 GMT</td>
+<td align="left">Last revised: September 15, 2011 at 15:07:54 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk