Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r75899 - in sandbox/contract/libs/contract/doc/html: . contract__
From: lorcaminiti_at_[hidden]
Date: 2011-12-11 06:34:22

Next message: ghost_at_[hidden]: "[Boost-commit] svn:boost r75900 - trunk"
Previous message: dnljms_at_[hidden]: "[Boost-commit] svn:boost r75896 - branches/quickbook-dev/tools/quickbook/src"

Author: lcaminiti
Date: 2011-12-11 06:34:17 EST (Sun, 11 Dec 2011)
New Revision: 75899
URL: http://svn.boost.org/trac/boost/changeset/75899

Log:
Upd docs.
Text files modified:
   sandbox/contract/libs/contract/doc/html/contract__/examples.html | 601 +++++++++++++++++++--------------------
   sandbox/contract/libs/contract/doc/html/index.html | 2
   2 files changed, 291 insertions(+), 312 deletions(-)

Modified: sandbox/contract/libs/contract/doc/html/contract__/examples.html
==============================================================================
--- sandbox/contract/libs/contract/doc/html/contract__/examples.html (original)
+++ sandbox/contract/libs/contract/doc/html/contract__/examples.html 2011-12-11 06:34:17 EST (Sun, 11 Dec 2011)
@@ -106,15 +106,13 @@
<dt><a href="examples.html#contract__.examples.__named_parameters___python__def___deduced_named_parameters">[Named
 Parameters] Python <code class="computeroutput">def</code>: Deduced
 named parameters</a></dt>
+<dt><a href="examples.html#contract__.examples.__named_parameters___calls__member_functions_with_named_parameters">[Named
+ Parameters] Calls: Member functions with named parameters</a></dt>
+<dt><a href="examples.html#contract__.examples.__named_parameters___family__constructors_with_named_parameters">[Named
+ Parameters] Family: Constructors with named parameters</a></dt>
<dt><a href="examples.html#contract__.examples.__named_parameters___python__class___named_template_parameters">[Named
 Parameters] Python <code class="computeroutput">class</code>: Named
 template parameters</a></dt>
-<dt><a href="examples.html#contract__.examples.__named_parameters___calls__member_functions_with_named_parameters">[Named
- Parameters] Calls: Member functions with named parameters</a></dt>
-<dt><a href="examples.html#contract__.examples.__named_parameters___my_class__constructors_with_named_parameters">[Named
- Parameters] My Class: Constructors with named parameters</a></dt>
-<dt><a href="examples.html#contract__.examples.__named_parameters___positive_number__fine_grained_parameter_name_control">[Named
- Parameters] Positive Number: Fine-grained parameter name control</a></dt>
</dl></div>

 This section lists quite a few examples programmed using this library and taken
@@ -638,7 +636,7 @@
 auto old_self = CONTRACT_OLDOF *this,
 auto old_right = CONTRACT_OLDOF right,
 right == old_self, requires boost::has_equal_to<T>::value,
- old_right == * this, requires boost::has_equal_to<T>::value
+ old_right == *this, requires boost::has_equal_to<T>::value
 )
 ) {
 vect_.swap(right);
@@ -1402,18 +1400,18 @@


<pre class="programlisting">#include <contract.hpp>
-#include <boost/type_traits/can_call_equal.hpp>
+#include <boost/type_traits/has_equal_to.hpp>
#include <boost/concept_check.hpp>

template< typename T >
-class Addable { // User-defined concept.
- T x;
- T y;
- void return_type ( T ); // Used to check addition returns type `T`.
-public:
+struct Addable { // User-defined concept.
 BOOST_CONCEPT_USAGE(Addable) {
 return_type(x + y); // Check addition `T operator+(T x, T y)`.
 }
+private:
+ T x;
+ T y;
+ void return_type ( T const& ); // Used to check addition returns type `T`.
};

CONTRACT_FUNCTION(
@@ -1421,7 +1419,7 @@
(T) (add) ( (T) x, (T) y )
 postcondition(
 auto result = return,
- result == x + y, requires boost::can_call_equal<T>::value
+ result == x + y, requires boost::has_equal_to<T>::value
 )
) {
 return x + y;
@@ -1438,7 +1436,6 @@


<pre class="programlisting">#include <contract.hpp>
-#include <boost/type_traits/can_call_equal.hpp>
#include <boost/mpl/bool.hpp>
#include <vector>
#include <list>
@@ -1558,7 +1555,7 @@


<pre class="programlisting">#include <contract.hpp>
-#include <boost/type_traits/can_call_equal.hpp>
+#include <boost/type_traits/has_equal_to.hpp>
#include <boost/concept_check.hpp>

// Use assertion requirements to model assertion computational complexity.
@@ -1577,9 +1574,9 @@
 auto return_value = return,
 result == op(arg0),
 requires O_BODY <= COMPLEXITY_MAX &&
- boost::can_call_equal<Result>::value,
+ boost::has_equal_to<Result>::value,
 return_value == result,
- requires boost::can_call_equal<Result>::value
+ requires boost::has_equal_to<Result>::value
 )
) {
 return result = op(arg0);
@@ -1596,9 +1593,9 @@
 auto return_value = return,
 result == op(arg0, arg1),
 requires O_BODY <= COMPLEXITY_MAX &&
- boost::can_call_equal<Result>::value,
+ boost::has_equal_to<Result>::value,
 return_value == result,
- requires boost::can_call_equal<Result>::value
+ requires boost::has_equal_to<Result>::value
 )
) {
 return result = op(arg0, arg1);
@@ -1615,7 +1612,7 @@


<pre class="programlisting">#include <contract.hpp>
-#include <boost/type_traits/can_call_equal.hpp>
+#include <boost/type_traits/has_equal_to.hpp>
#include <boost/concept_check.hpp>

CONTRACT_FUNCTION(
@@ -1629,7 +1626,7 @@
 // Precondition: Range [first, last) is valid.
 postcondition(
 auto result = return,
- result == func, requires boost::can_call_equal<Func>::value
+ result == func, requires boost::has_equal_to<Func>::value
 )
) {
 CONTRACT_LOOP( while(first < last) ) { // OK: Iter is InputIterator.
@@ -1655,7 +1652,7 @@
#define CONTRACT_CONFIG_FUNCTION_ARITY_MAX 6

#include <contract.hpp>
-#include <boost/type_traits/can_call_equal.hpp>
+#include <boost/type_traits/has_equal_to.hpp>
#include <boost/concept_check.hpp>
#include <algorithm>

@@ -1676,7 +1673,7 @@
 // Precondition: Range [first1, last1) is valid.
 postcondition(
 auto return_value = return,
- return_value == result, requires boost::can_call_equal<OutIter>::value
+ return_value == result, requires boost::has_equal_to<OutIter>::value
 )
) {
 return std::transform(first1, last1, first2, result, op);
@@ -1801,7 +1798,7 @@


<pre class="programlisting">#include <contract.hpp>
-#include <boost/type_traits/can_call_equal.hpp>
+#include <boost/type_traits/has_equal_to.hpp>
#include <boost/concept_check.hpp>

CONTRACT_FUNCTION(
@@ -1815,7 +1812,7 @@
 // Precondition: Iterator i is non-singular.
 postcondition(
 auto result = return,
- result == *i, requires boost::can_call_equal<typename
+ result == *i, requires boost::has_equal_to<typename
 boost::InputIterator<Iter>::value_type>::value
 )
) {
@@ -1833,7 +1830,7 @@


<pre class="programlisting">#include <contract.hpp>
-#include <boost/type_traits/can_call_equal.hpp>
+#include <boost/type_traits/has_equal_to.hpp>
#include <boost/concept_check.hpp>

CONTRACT_FUNCTION(
@@ -1842,7 +1839,7 @@
 postcondition(
 auto result = return,
 x < y ? result == x : result == y,
- requires boost::can_call_equal<T>::value
+ requires boost::has_equal_to<T>::value
 )
) {
 return x < y ? x : y; // OK: T is less than comparable `<`.
@@ -4462,8 +4459,8 @@


<pre class="programlisting">#include <contract.hpp>
-#include <boost/type_traits/can_call_equal.hpp>
-#include <boost/type_traits/can_call_greater.hpp>
+#include <boost/type_traits/has_equal_to.hpp>
+#include <boost/type_traits/has_greater.hpp>
#include <boost/concept_check.hpp>
#include <boost/utility.hpp>
#include <iostream>
@@ -4488,9 +4485,9 @@
 // skip this assertion if `has_oldof<T>::value` is false
 value > old_value, // also skip if T has no operator>
 requires contract::has_oldof<T>::value && // need old-of
- boost::can_call_greater<T>::value, // need >
+ boost::has_greater<T>::value, // need >
 result == value, // skip this assertion if T has no operator==
- requires boost::can_call_equal<T>::value // need ==
+ requires boost::has_equal_to<T>::value // need ==
 )
) {
 return ++value;
@@ -4536,6 +4533,7 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/parameter.hpp> // For named parameters.
#include <boost/utility/identity.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/depth_first_search.hpp>
@@ -4545,14 +4543,21 @@
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/placeholders.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/property_map/shared_array_property_map.hpp>
#include <boost/mpl/and.hpp>
+#include <boost/mpl/placeholders.hpp>
#include <iostream>

-namespace graphs
-{
+namespace graphs {

-// Some helper graph metafunctions.
+// Helpers.
+
+template< typename G >
+struct vertex_descriptor
+{
+ typedef typename boost::graph_traits<G>::vertex_descriptor type;
+};

template< typename T >
struct is_incidence_and_vertex_list_graph :
@@ -4577,19 +4582,20 @@
struct is_integral_property_map_of_key :
 boost::mpl::and_<
 boost::is_integral<typename boost::property_traits<T>::value_type>
- , is_property_map_of_key<T, Key>
+ , is_property_map_of_key<T, typename Key::type>
 >
{};

template< typename Size, typename IndexMap >
-boost::iterator_property_map<boost::default_color_type*, IndexMap,
- boost::default_color_type, boost::default_color_type&>
+boost::shared_array_property_map<boost::default_color_type, IndexMap>
default_color_map ( Size const& num_vertices, IndexMap const& index_map )
{
- std::vector<boost::default_color_type> colors(num_vertices);
- return &colors[0];
+ return boost::make_shared_array_property_map(num_vertices,
+ boost::default_color_type(), index_map);
}

+// Function with named parameters.
+
CONTRACT_PARAMETER(graph)
CONTRACT_PARAMETER(visitor)
CONTRACT_PARAMETER(root_vertex)
@@ -4598,31 +4604,27 @@

CONTRACT_FUNCTION(
void (depth_first_search) (
- // Required named parameter (no default value) with type requirement.
+ // Required parameter (no default value) with requirement predicate.
 in requires(is_incidence_and_vertex_list_graph<boost::mpl::_>) graph,
- // Optional named parameter (with default values) of any type (auto).
+ // Optional (default value) of any type (auto).
 in auto visitor, default boost::dfs_visitor<>(),
- // Optional named parameter (default value) with specific type.
- in (typename boost::graph_traits<tag::graph::_>::
- vertex_descriptor) root_vertex,
- default *boost::vertices(graph).first,
- // Optional named parameter (default value) with type requirement.
- in requires(BOOST_IDENTITY_TYPE((
- is_integral_property_map_of_key<
+ // Exact type specified.
+ in (vertex_descriptor<CONTRACT_PARAMETER_TYPEOF(graph)>) root_vertex,
+ default BOOST_IDENTITY_VALUE((*boost::vertices(graph).first)),
+ // Any type matching requirement predicate (unary meta-function).
+ in requires(BOOST_IDENTITY_TYPE((is_integral_property_map_of_key<
 boost::mpl::_
- , typename boost::graph_traits<tag::graph::_>::
- vertex_descriptor
+ , vertex_descriptor<CONTRACT_PARAMETER_TYPEOF(graph)>
 >))) index_map,
 default boost::get(boost::vertex_index, graph),
- // Optional output named parameter (default value) with type req.
- in out requires(BOOST_IDENTITY_TYPE((
- is_property_map_of_key<
+ // In-out parameter.
+ in out requires(BOOST_IDENTITY_TYPE((is_property_map_of_key<
 boost::mpl::_
- , typename boost::graph_traits<tag::graph::_>::
- vertex_descriptor
+ , vertex_descriptor<CONTRACT_PARAMETER_TYPEOF(graph)>
 >))) color_map,
 default default_color_map(boost::num_vertices(graph), index_map)
 )
+ // No `precondition(...)` or `postcondition(...)` in this example.
) {
 boost::depth_first_search(graph, boost::visitor(visitor).
 color_map(color_map).root_vertex(root_vertex).
@@ -4631,21 +4633,20 @@

} // namespace graphs

+// Main program.
+
template< typename TimeMap >
class dfs_time_visitor : public boost::default_dfs_visitor
{
- typedef typename boost::property_traits< TimeMap >::value_type T;
+ typedef typename boost::property_traits<TimeMap>::value_type T;
public:
- dfs_time_visitor(TimeMap dmap, TimeMap fmap, T& t)
- : dmap_(dmap), fmap_(fmap), time_(t)
- {}
-
+ dfs_time_visitor ( TimeMap dmap, TimeMap fmap, T& t ) :
+ dmap_(dmap), fmap_(fmap), time_(t) {}
 template< typename V, typename G >
 void discover_vertex ( V u, G const& g ) const { put(dmap_, u, time_++); }
-
 template< typename V, typename G >
 void finish_vertex ( V u, G const& g ) const { put(fmap_, u, time_++); }
-
+private:
 TimeMap dmap_;
 TimeMap fmap_;
 T& time_;
@@ -4668,7 +4669,8 @@
 size_type t = 0;
 dfs_time_visitor<size_type*> vis(&dtime[0], &ftime[0], t);

- graphs::depth_first_search(g, vis);
+ // Named parameter call.
+ graphs::depth_first_search(graphs::_visitor = vis, graphs::_graph = g);

 std::vector<size_type> dorder(N);
 boost::integer_range<size_type> r(0, N);
@@ -4701,20 +4703,54 @@
</h3></div></div></div>


-<pre class="programlisting">#include <contract.hpp>
-#include <boost/utility/identity.hpp>
-#include <boost/python.hpp>
+<pre class="programlisting">#include <boost/python.hpp>
+#include <contract.hpp>
+#include <contract/parameter.hpp> // For named parameters.
+#include <contract/concept.hpp> // For concepts.
+#include <boost/concept_check.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/type_traits/is_convertible.hpp>
+#include <boost/regex.hpp>
+#include <iostream>
+
+namespace py {
+
+// Helpers.
+
+template<class P>
+struct CallPolicies
+{
+ // BOOST_CONCEPT_ASSERT((ResultConverterGenerator<P::result_converter>));
+ // BOOST_CONCEPT_ASSERT((Metafunction<P::extract_return_type>));
+
+ BOOST_CONCEPT_USAGE(CallPolicies)
+ {
+ bool b = x.precall(a); // convertible to bool
+ PyObject* o = x.postcall(a, r); // convertible to PyObject*
+ }
+
+private:
+ P x;
+ PyObject* a;
+ PyObject* r;
+};

-namespace py
+bool is_identifier ( char const* name )
{
+ static const boost::regex re("(\\l|\\u|_)(\\l|\\u|\\d|_)*");
+ return boost::regex_match(name, re);
+}
+
+template< typename T > struct is_keyword_expression :
+ boost::mpl::bool_< boost::python::detail::is_keywords<T>::value >
+{};
+
+boost::python::detail::keywords<0> no_keywords()
+ { return boost::python::detail::keywords<0>(); }

-// For simplicity, trivial helper implementations.
-bool is_valid_identifier ( char const* name ) { return true; }
-template< typename T > struct is_keyword_expression : boost::mpl::true_ {};
+// Function with named parameters.

CONTRACT_PARAMETER(name)
CONTRACT_PARAMETER(func)
@@ -4724,153 +4760,43 @@

CONTRACT_FUNCTION(
void (def) (
- // Non-deduced and required named parameters.
- in (char const*) name, // Specified type.
- in auto func, // Any type (auto).
- // Deduced and optional (with default value) named parameters.
- deduce in (char const *) docstring, default "", // Specified type.
- // Type requirements also used to uniquely deduce parameters.
- deduce in requires(is_keyword_expression<boost::mpl::_>) keywords,
- default boost::python::detail::keyword_range(),
- deduce in requires(BOOST_IDENITITY_TYPE((
- boost::mpl::not_<
- boost::mpl::or_<
- boost::is_convertible<boost::mpl::_, char const*>
- , is_keyword_expression<boost::mpl::_>
- >
- >))) policies,
- default boost::python::default_call_policies()
- )
- precondition( is_valid_identifier(name) ) // Also with contract.
+ // Non-deduced (and also required) named parameters.
+ in (char const*) name,
+ in auto func,
+ // Deduced (and also optional) named parameters.
+ deduce in (char const*) docstring, default "",
+ deduce in requires(is_keyword_expression<boost::mpl::_>) keywords,
+ default no_keywords(),
+ // Type requirements also used to 
+ deduce in requires(BOOST_IDENTITY_TYPE((
+ boost::mpl::not_<
+ boost::mpl::or_<
+ boost::is_convertible<boost::mpl::_, char const*>
+ , is_keyword_expression<boost::mpl::_>
+ >
+ >))) policies,
+ default boost::python::default_call_policies()
+ ) requires( CallPolicies<CONTRACT_PARAMETER_TYPEOF(policies)> ) // Concepts.
+ precondition( is_identifier(name) ) // Contracts.
) {
 boost::python::def(name, func, docstring, keywords, policies);
}

} // namespace py

-void f ( void ) {}
-
-int main ( void )
-{
- int some_policies = 123;
- py::def("f", &f, some_policies, "Documentation for f");
- py::def("f", &f, "Documentation for f", some_policies);
-
- char const* other_policies = "abc";
- py::def("f", &f, py::_policies = other_policies, "Documentation for f");
-
- return 0;
-}
-</pre>
-
- 
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="contract__.examples.__named_parameters___python__class___named_template_parameters"></a><a class="link" href="examples.html#contract__.examples.__named_parameters___python__class___named_template_parameters" title="[Named Parameters] Python class: Named template parameters">[Named
- Parameters] Python <code class="computeroutput">class</code>: Named
- template parameters</a>
-</h3></div></div></div>
-
-
-<pre class="programlisting">#include <contract.hpp>
-#include <boost/utility/identity.hpp>
-#include <boost/python.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/shared_ptr.hpp>
-
-namespace py
-{
-
-namespace detail { struct bases_tag {}; }
-
-template< class B0 = void, class B1 = void, class B2 = void >
-struct bases : detail::bases_tag {};
-
-CONTRACT_TEMPLATE_PARAMETER(ClassType)
-CONTRACT_TEMPLATE_PARAMETER(BaseList)
-CONTRACT_TEMPLATE_PARAMETER(HeldType)
-CONTRACT_TEMPLATE_PARAMETER(Copyable)
-
-CONTRACT_CLASS(
-template(
- // Required named template parameter with type requirement.
- in requires(boost::is_class<boost::mpl::_>) ClassType,
- // Deduced and optional named template parameters with type requirements.
- deduce in requires(BOOST_IDENTITY_TYPE((boost::is_base_and_derived<
- detail::bases_tag, boost::mpl::_>))) BaseList,
- default bases<>,
- deduce in requires(BOOST_IDENTITY_TYPE((
- boost::mpl::or_<
- boost::mpl::or_<
- boost::is_base_and_derived<detail::bases_tag,
- boost::mpl::_>
- , boost::is_same<boost::noncopyable, boost::mpl::_>
- >
- >))) HeldType,
- default ClassType,
- deduce in requires(BOOST_IDENTITY_TYPE((boost::is_same<
- boost::noncopyable, boost::mpl::_>))) Copyable,
- default void
- // NOTE: Named template params do not directly support non-type params.
-)
-class (class_)
- extends(
- public BOOST_IDENTITY_TYPE((boost::python::class_<ClassType, BaseList,
- HeldType, Copyable>))
- )
-) {
- CONTRACT_CLASS_INVARIANT( void )
-
-public:
- typedef ClassType class_type;
- typedef BaseList base_list;
- typedef HeldType held_type;
- typedef Copyable copyable;
-};
-
-} // namespace py
-
-struct b { virtual ~b() = 0; };
-struct d : b { ~d() {} };
-
-// Named parameters.
-typedef py::class_< py::_ClassType<b>, py::_Copyable<boost::noncopyable> > x1;
-typedef py::class_< d, py::_HeldType< boost::shared_ptr<d> >,
- py::BaseList< py::bases<b> > > x2;
-// Deduced parameters.
-typedef py::class_< b, boost::noncopyable > y1;
-typedef py::class_< d, boost::shared_ptr<d>, py::bases<b> > y2;
-
-BOOST_MPL_ASSERT(( boost::is_same< x1::class_type, b > ));
-BOOST_MPL_ASSERT(( boost::is_same< x1::base_list, py::bases<> > ));
-BOOST_MPL_ASSERT(( boost::is_same< x1::held_type, b > ));
-BOOST_MPL_ASSERT(( boost::is_same< x1::copyable, boost::noncopyable > ));
-
-BOOST_MPL_ASSERT(( boost::is_same< x2::class_type, d > ));
-BOOST_MPL_ASSERT(( boost::is_same< x2::base_list, py::bases<b> > ));
-BOOST_MPL_ASSERT(( boost::is_same< x2::held_type, boost::shared_ptr<d> > ));
-BOOST_MPL_ASSERT(( boost::is_same< x2::copyable, void > ));
-
-BOOST_MPL_ASSERT(( boost::is_same< y1::class_type, b > ));
-BOOST_MPL_ASSERT(( boost::is_same< y1::base_list, py::bases<> > ));
-BOOST_MPL_ASSERT(( boost::is_same< y1::held_type, b > ));
-BOOST_MPL_ASSERT(( boost::is_same< y1::copyable, boost::noncopyable > ));
-
-BOOST_MPL_ASSERT(( boost::is_same< y2::class_type, d > ));
-BOOST_MPL_ASSERT(( boost::is_same< y2::base_list, py::bases<b> > ));
-BOOST_MPL_ASSERT(( boost::is_same< y2::held_type, boost::shared_ptr<d> > ));
-BOOST_MPL_ASSERT(( boost::is_same< y2::copyable, void > ));
+template< char Name >
+void print ( void ) { std::cout << "called " << Name << std::endl; }

-int main ( void )
+// Python module, in a Python shell from this directory run:
+// >>> import pydef # This will check contracts (preconditions, etc).
+// >>> help("pydef"), pydef.f(), pydef.g(), pydef.h()
+BOOST_PYTHON_MODULE(pydef)
{
- return 0;
+ boost::python::default_call_policies some_policies;
+ py::def("f", print<'f'>, some_policies, "Documentation for f");
+ py::def("g", print<'g'>, "Documentation for g", some_policies);
+ py::def("h", print<'h'>, py::_policies = some_policies,
+ "Documentation for h");
}
</pre>

@@ -4884,10 +4810,10 @@


<pre class="programlisting">#include <contract.hpp>
+#include <contract/parameter.hpp>
#include <iostream>

-namespace calls
-{
+namespace calls {

CONTRACT_PARAMETER(arg1)
CONTRACT_PARAMETER(arg2)
@@ -4899,30 +4825,26 @@

 CONTRACT_FUNCTION( // Member function with named parameters.
 public void (call) ( in int arg1, in int arg2 )
- ) {
- call_impl(arg1, arg2, "");
- }
+ ) ; // Body definition can be separated as usual...

 CONTRACT_FUNCTION( // Constant member with named parameters.
 public void (call) ( in int arg1, in int arg2 ) const
 ) {
- call_impl(arg1, arg2, "const");
+ std::cout << "const: " << arg1 << ", " << arg2 << std::endl;
 }

 CONTRACT_FUNCTION( // Static member with named parameters.
 public static void (scall) ( in int arg1, in int arg2 )
 ) {
- call_impl(arg1, arg2, "static");
+ std::cout << "static: " << arg1 << ", " << arg2 << std::endl;
 }
-
-private:
- // NOTE: Function definition with named params cannot be directly separated.
- static void call_impl ( int arg1, int arg2, char const* qualifier ) ;
};

-void callable2::call_impl( int arg1, int arg2, char const* what )
+// ... but separated body definition uses generic template parameters.
+template< typename Arg1, typename Arg2 >
+void callable2::CONTRACT_MEMBER_BODY(call)( Arg1 arg1, Arg2 arg2 )
{
- std::cout << arg1 << ", " << arg2 << " (" << what << ")" << std::endl;
+ std::cout << "member: " << arg1 << ", " << arg2 << std::endl;
}

} // namespace calls
@@ -4945,49 +4867,96 @@
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
-<a name="contract__.examples.__named_parameters___my_class__constructors_with_named_parameters"></a><a class="link" href="examples.html#contract__.examples.__named_parameters___my_class__constructors_with_named_parameters" title="[Named Parameters] My Class: Constructors with named parameters">[Named
- Parameters] My Class: Constructors with named parameters</a>
+<a name="contract__.examples.__named_parameters___family__constructors_with_named_parameters"></a><a class="link" href="examples.html#contract__.examples.__named_parameters___family__constructors_with_named_parameters" title="[Named Parameters] Family: Constructors with named parameters">[Named
+ Parameters] Family: Constructors with named parameters</a>
</h3></div></div></div>


<pre class="programlisting">#include <contract.hpp>
+#include <contract/parameter.hpp> // For named parameters.
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <string>
+#include <vector>
#include <iostream>

-namespace mine {
+namespace family {

-CONTRACT_PARAMETER(name)
-CONTRACT_PARAMETER(index)
-
-// NOTE: Constructors with named parameters need to be implement in bases.
-struct myclass_params
+struct person
{
- template< typename Name, typename Index >
- myclass_params ( Name name, Index index )
- {
- std::cout << "name = " << name << "; index = " << index << std::endl;
+ std::string name_;
+ int age_;
+ double weight_;
+
+ template< typename Name, typename Age, typename Weight >
+ person ( Name name, Age age, Weight weight )
+ : name_(name), age_(age), weight_(weight) {
+ std::cout << name << ": " << age << " year(s), " << weight << " Kg";
+ }
+ person& operator= ( person const& right ) {
+ name_ = right.name_; age_ = right.age_; weight_ = right.weight_;
+ return *this;
 }
};

+CONTRACT_PARAMETER(name)
+CONTRACT_PARAMETER(age)
+CONTRACT_PARAMETER(relatives)
+CONTRACT_PARAMETER(weight)
+
CONTRACT_CLASS(
-struct (myclass) extends( myclass_params )
+struct (member) extends( public person )
) {
 CONTRACT_CLASS_INVARIANT( void )

 CONTRACT_CONSTRUCTOR(
- public explicit (myclass) ( in auto name, in auto index, default 42 )
- initialize( myclass_params(CONTRACT_CONSTRUCTOR_PARAMETERS) )
- /** @todo are contracts still checked pre > inv > body > post > inv? */
- /* or pre > body > inv > post > inv which is incorrect! */
- ) {}
+ public (member) (
+ in auto name,
+ in out auto age, default 32,
+ deduce out (std::vector<person>) relatives,
+ deduce in requires(BOOST_IDENTITY_TYPE((
+ boost::is_convertible<boost::mpl::_, double>))) weight,
+ default double(78.9)
+ ) // Preconditions, body, etc access arguments as usual...
+ precondition( std::string(name) != "", age >= 0, weight >= 0.0 )
+ postcondition(
+ auto old_relatives_size = CONTRACT_OLDOF relatives.size(),
+ relatives.size() == old_relatives_size + 1
+ )
+ initialize( // ... but initializers must use the _ARG macro.
+ person(CONTRACT_CONSTRUCTOR_ARG(name),
+ CONTRACT_CONSTRUCTOR_ARG(age),
+ CONTRACT_CONSTRUCTOR_ARG(weight)),
+ family_(CONTRACT_CONSTRUCTOR_ARG(relatives))
+ )
+ ) {
+ std::cout << ", " << relatives.size() << " relative(s)" << std::endl;
+ relatives.push_back(*this);
+ }
+
+private:
+ std::vector<person>& family_;
};

-} // namespace mine
+} // namespace family

int main ( void )
{
- mine::myclass x("bob", 3);
- mine::myclass y(mine::_index = 12, mine::_name = "sally");
- mine::myclass z("june");
+ int a = 23;
+ std::vector<family::person> p;
+
+ family::member m1(family::_name = "Mary", family::_relatives = p);
+ family::member m2(family::_relatives = p, family::_name = "Mike");
+
+ family::member m3(family::_relatives = p, family::_name = "Lisa",
+ family::_age = a);
+ family::member m4(family::_relatives = p, family::_weight = 65.4,
+ family::_name = "John");
+
+ family::member m5(family::_age = a, family::_relatives = p,
+ family::_weight = 65.4, family::_name = "July");
+ family::member m6("Paul", a, p, 65.4);
+
 return 0;
}
</pre>
@@ -4996,92 +4965,102 @@
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
-<a name="contract__.examples.__named_parameters___positive_number__fine_grained_parameter_name_control"></a><a class="link" href="examples.html#contract__.examples.__named_parameters___positive_number__fine_grained_parameter_name_control" title="[Named Parameters] Positive Number: Fine-grained parameter name control">[Named
- Parameters] Positive Number: Fine-grained parameter name control</a>
+<a name="contract__.examples.__named_parameters___python__class___named_template_parameters"></a><a class="link" href="examples.html#contract__.examples.__named_parameters___python__class___named_template_parameters" title="[Named Parameters] Python class: Named template parameters">[Named
+ Parameters] Python <code class="computeroutput">class</code>: Named
+ template parameters</a>
</h3></div></div></div>


-<pre class="programlisting">#include <contract.hpp>
-#include <boost/type_traits/has_equal_to.hpp>
+<pre class="programlisting">#include <boost/python.hpp>
+#include <contract.hpp>
+#include <contract/parameter.hpp> // For named parameters.
+#include <contract/parameter.hpp> // For concepts.
+#include <boost/concept_check.hpp>
+#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/long.hpp>
-#include <boost/mpl/char.hpp>
-#include <iostream>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/regex.hpp>

-namespace num
-{
+namespace py {

-namespace tag // Namespace `tag` already used here, use `keywords` instead.
+// Helpers.
+
+bool is_identifier ( char const* name )
{
- typedef int Value; // Dummy declarations...
- typedef int Default;
- Value value = Default();
+ static const boost::regex re("(\\l|\\u|_)(\\l|\\u|\\d|_)*");
+ return boost::regex_match(name, re);
}

-// Also use `Param` and `_param` postfixes instead of `_` prefix.
-CONTRACT_PARAMETER_TEMPLATE((ValueParam, keywords) Value)
-CONTRACT_PARAMETER_TEMPLATE((DefaultParam, keywords) Default)
-CONTRACT_PARAMETER((value_param, keywords) value)
+// Class template with named parameters.
+
+CONTRACT_TEMPLATE_PARAMETER(ClassType)
+CONTRACT_TEMPLATE_PARAMETER(Bases)
+CONTRACT_TEMPLATE_PARAMETER(HeldType)
+CONTRACT_TEMPLATE_PARAMETER(Copyable)
+CONTRACT_PARAMETER(name)

CONTRACT_CLASS(
template(
- namespace keywords, // Use namespace `keywords` instead of `tag`.
- in typename Value, default int,
- in requires(is_same<boost::mpl::_::type, Value>) Default,
- default boost::mpl::int_<0>
-)
-struct (positive)
+ // Required named template parameter.
+ in typename requires(boost::is_class<boost::mpl::_>) ClassType,
+ // Deduced and optional named template parameters with type requirements.
+ deduce in typename requires(boost::python::detail::specifies_bases<
+ boost::mpl::_>) Bases,
+ default boost::python::bases<>,
+ deduce in typename requires(BOOST_IDENTITY_TYPE((boost::mpl::not_<
+ boost::mpl::or_<
+ boost::python::detail::specifies_bases<boost::mpl::_>
+ , boost::is_same<boost::noncopyable, boost::mpl::_>
+ >
+ >))) HeldType,
+ default boost::python::detail::not_specified,
+ deduce in typename requires(BOOST_IDENTITY_TYPE((
+ boost::is_same<boost::noncopyable, boost::mpl::_>
+ ))) Copyable,
+ default boost::python::detail::not_specified
+ // Note: Non-type template parameters are not supported by named parameters.
+) requires( boost::DefaultConstructible<ClassType> )
+class (class_) extends( BOOST_IDENTITY_TYPE((
+ boost::python::class_<ClassType, Bases, HeldType, Copyable>)) )
) {
- CONTRACT_CLASS_INVARIANT(
- static class( Default::value > 0 ),
- get() > 0
- )
+ CONTRACT_CLASS_INVARIANT_TPL( void )

- CONTRACT_CONSTRUCTOR(
- public (positive) ( void )
- initialize( value_(Default::value) )
- ) {}
+ typedef boost::python::class_<ClassType, Bases, HeldType, Copyable>
+ boost_python_class;

- CONTRACT_FUNCTION(
- public void (set) ( namespace keywords, in (Value) value )
- precondition( value > 0 )
- postcondition(
- get() == value, requires boost::has_euql_to<Value>::value
- )
- ) {
- value_ = value;
- }
-
- CONTRACT_FUNCTION(
- public (Value const&) (get) ( void ) const
- ) {
- return value_;
- }
+public:

-private:
- Value value_;
+ CONTRACT_CONSTRUCTOR_TPL(
+ public (class_) ( in (char const*) name )
+ precondition( is_identifier(name) )
+ initialize( boost_python_class(CONTRACT_CONSTRUCTOR_ARG(name)) )
+ ) {}
};

-} // namespace num
+} // namespace py

-int main ( value )
-{
- num::positive< char, boost::mpl::char_<'z'> > p;
- num::positive< > q;
+struct bx { virtual ~bx ( void ) {} };
+struct x : bx {};

- // Use `...Param` instead of `_...`.
- num::positive< num::DefaultParam< boost::mpl::int_<10> > > r;
- num::positive<
- num::DefaultParam< boost::mpl::long_<10> >
- , num::ValueParam<long>
- > s;
-
- std::cout << s.get() << std::endl;
- s.set(num::value_param = 123); // Use `..._param` instead of `_...`.
- std::cout << s.get() << std::endl;
+struct by { virtual ~by ( void ) {} };
+struct y : by { };

- return 0;
+// Python module, in a Python shell from this directory run:
+// >>> import pyclass # This will check contracts (preconditions, etc).
+// >>> help("pyclass"), xx = pyclass.x(), yy = pyclass.x()
+BOOST_PYTHON_MODULE(pyclass)
+{
+ // Named parameters.
+ py::class_<py::_ClassType<bx>, py::_Copyable<boost::noncopyable> >("bx");
+ py::class_<x, py::_HeldType<boost::shared_ptr<x> >,
+ py::_Bases<boost::python::bases<bx> > >("x");
+ // Deduced parameters.
+ py::class_<by, boost::noncopyable>("by");
+ py::class_<y, boost::shared_ptr<y>, boost::python::bases<by> >(
+ py::_name = "y");
}
</pre>

Modified: sandbox/contract/libs/contract/doc/html/index.html
==============================================================================
--- sandbox/contract/libs/contract/doc/html/index.html (original)
+++ sandbox/contract/libs/contract/doc/html/index.html 2011-12-11 06:34:17 EST (Sun, 11 Dec 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: November 07, 2011 at 02:18:04 GMT</td>
+<td align="left">Last revised: December 10, 2011 at 20:55:15 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Next message: ghost_at_[hidden]: "[Boost-commit] svn:boost r75900 - trunk"
Previous message: dnljms_at_[hidden]: "[Boost-commit] svn:boost r75896 - branches/quickbook-dev/tools/quickbook/src"

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