townforge/contract
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

impl virtual_*

Browse Source
This commit is contained in:
Lorenzo Caminiti 2015-05-25 15:37:52 -07:00
parent 0c90570e6c
commit 7bb102aa82
24 changed files with 630 additions and 757 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
include/boost/contract/aux_/call.hpp
View File

@ -1,33 +0,0 @@
#ifndef BOOST_CONTRACT_AUX_CALL_HPP_
#define BOOST_CONTRACT_AUX_CALL_HPP_
/** @cond */
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <queue>
/** @endcond */
namespace boost { namespace contract { namespace aux {
struct call : private boost::noncopyable { // Do not copy queue.
enum action_enum {
// Call always hold by ptr so null ptr (not enum) used for user-call.
copy_oldof,
check_entry_inv,
check_pre,
check_post,
check_exit_inv
};
explicit call() : action(), after_contract(false), old_values() {}
action_enum action;
bool after_contract;
std::queue<boost::shared_ptr<void> > old_values;
};
} } } // namespace
#endif // #include guard

16
include/boost/contract/aux_/condition/check_base.hpp
View File

@ -1,16 +0,0 @@
#ifndef BOOST_CONTRACT_AUX_CHECK_NOTHING_HPP_
#define BOOST_CONTRACT_AUX_CHECK_NOTHING_HPP_
namespace boost { namespace contract { namespace aux {
// Base class for all contracts (used to hold RAII contract object, etc.).
class check_base {
public:
virtual ~check_base() {}
};
} } } // namespace
#endif // #include guard

60
include/boost/contract/aux_/condition/check_pre_post.hpp
View File

@ -3,9 +3,6 @@
#define BOOST_CONTRACT_AUX_CHECK_PRE_POST_HPP_
#include <boost/contract/core/exception.hpp>
#include <boost/contract/aux_/condition/check_base.hpp>
#include <boost/contract/aux_/call.hpp>
#include <boost/contract/aux_/exception.hpp>
/** @cond */
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp> // TODO: Can I reduce boost.function overhead?
@ -17,15 +14,10 @@ namespace boost { namespace contract { namespace aux {
// (if function is a lambda) and it could be expensive... check all classes
// that MUST be copiable, make sure their copies are effecient, make all other
// calsses noncopyable.
class check_pre_post : public check_base {
class check_pre_post {
public:
explicit check_pre_post(boost::contract::from from) : from_(from) {}
explicit check_pre_post(boost::contract::from from,
boost::shared_ptr<call> _call) : from_(from), decl_call_(_call) {
if(decl_call_) decl_call_->after_contract = true;
}
virtual ~check_pre_post() {}
template<typename F>
@ -36,46 +28,21 @@ public:
protected:
void check_pre(bool throw_on_failure = false) {
if(!decl_call_ || decl_call_->action == call::check_pre) {
if(pre_) {
try { pre_(); }
catch(...) {
// Subcontracted pre must throw on failure (instead of
// calling failure handler) so to be checked in logic-or.
if(throw_on_failure) throw;
boost::contract::precondition_failed(from_);
}
if(pre_) {
try { pre_(); }
catch(...) {
// Subcontracted pre must throw on failure (instead of
// calling failure handler) so to be checked in logic-or.
if(throw_on_failure) throw;
boost::contract::precondition_failed(from_);
}
if(decl_call_) throw no_error();
}
}
// TODO: I should be able to get rid of throw no_error everywhere (because
// the checking call_ allows the rest of the code to just do nothing). That
// way post and exit_inv checking can go in dtor also when bind is used.
// That will require to use scoped contract = ... also in contract decl
// functions.
// Then I should be able to set a state in c to false when a
// contract decl func is first called and then to true after the
// scoped contract = ... assignment is done. OLDOF can check that state so
// if I add from bind a call with action coped_entry_oldof and
// copy_oldof_after_pre_and_inv, I can then support copying old values
// after pre/inv have been checked also in contract decl func when users
// simply assign old values old_x = OLDOF(c, ...) after the contract decl
// (old_x variable will always have to be decl before the contract decl, but
// assigned before the contract decl to be copied before pre/inv, or after
// the contract decl to be copied after pre/inv). The same syntax, assigned
// before/after contract decl, can be used when bind is not used (that
// should work without changing current impl).
// If call(), can't call from a dtor (as throw no_error on OK).
void check_post() {
if(!decl_call_ || decl_call_->action == call::check_post) {
if(post_) {
try { post_(); }
catch(...) { boost::contract::postcondition_failed(from_); }
}
if(decl_call_) throw no_error();
if(post_) {
try { post_(); }
catch(...) { boost::contract::postcondition_failed(from_); }
}
}
@ -84,13 +51,10 @@ protected:
boost::contract::from from() const { return from_; }
boost::shared_ptr<call> decl_call() { return decl_call_; }
private:
boost::contract::from from_;
boost::function<void ()> pre_;
boost::function<void ()> post_;
boost::contract::from from_;
boost::shared_ptr<call> decl_call_;
};
} } }

34
include/boost/contract/aux_/condition/check_pre_post_inv.hpp
View File

@ -5,9 +5,7 @@
#include <boost/contract/core/config.hpp>
#include <boost/contract/core/exception.hpp>
#include <boost/contract/aux_/condition/check_pre_post.hpp>
#include <boost/contract/aux_/call.hpp>
#include <boost/contract/aux_/type_traits/invariant.hpp>
#include <boost/contract/aux_/exception.hpp>
/** @cond */
#include <boost/mpl/bool.hpp>
#include <boost/shared_ptr.hpp>
@ -18,35 +16,21 @@ namespace boost { namespace contract { namespace aux {
template<class C>
class check_pre_post_inv : public check_pre_post { // Copyable (as *).
public:
explicit check_pre_post_inv(boost::contract::from from, C const* obj) :
explicit check_pre_post_inv(boost::contract::from from, C* obj) :
check_pre_post(from), obj_(obj) {}
explicit check_pre_post_inv(boost::contract::from from, boost::shared_ptr<
call> decl_call, C const* obj) :
check_pre_post(from, decl_call), obj_(obj)
{}
virtual ~check_pre_post_inv() {}
protected:
void check_entry_inv(bool static_inv_only = false) {
if(!this->decl_call() || this->decl_call()->action ==
call::check_entry_inv) {
check_inv(/* on_entry = */ true, static_inv_only);
if(this->decl_call()) throw no_error();
}
void check_entry_inv() {
check_inv(/* on_enty = */ true, /* static_inv_only = */ false);
}
void check_exit_inv() {
check_inv(/* on_enty = */ false, /* static_inv_only = */ false);
}
// If call(), can't call from dtor (as throw no_error on OK).
void check_exit_inv(bool static_inv_only = false) {
if(!this->decl_call() || this->decl_call()->action ==
call::check_exit_inv) {
check_inv(/* on_entry = */ false, static_inv_only);
if(this->decl_call()) throw no_error();
}
}
C const* object() const { return obj_; }
C* object() { return obj_; }
private:
void check_inv(bool on_entry, bool static_inv_only) {
@ -84,7 +68,7 @@ private:
// TODO: Add volatile inv here...
C const* obj_;
C* obj_;
};
} } }

192
include/boost/contract/aux_/condition/check_subcontracted_pre_post_inv.hpp
View File

@ -2,10 +2,10 @@
#ifndef BOOST_CONTRACT_AUX_CHECK_SUBCONTRACTED_PRE_POST_INV_HPP_
#define BOOST_CONTRACT_AUX_CHECK_SUBCONTRACTED_PRE_POST_INV_HPP_
#include <boost/contract/core/decl.hpp>
#include <boost/contract/core/virtual.hpp>
#include <boost/contract/aux_/condition/check_pre_post_inv.hpp>
#include <boost/contract/aux_/type_traits/base_types.hpp>
#include <boost/contract/aux_/exception.hpp>
#include <boost/contract/aux_/type_traits/member_function_types.hpp>
#include <boost/contract/aux_/debug.hpp>
/** @cond */
#include <boost/function_types/result_type.hpp>
@ -14,6 +14,8 @@
#include <boost/function_types/property_tags.hpp>
#include <boost/type_traits/add_pointer.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/transform.hpp>
@ -21,6 +23,7 @@
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/back.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/placeholders.hpp>
@ -34,7 +37,8 @@ namespace boost { namespace contract { namespace aux {
// TODO: Can I make this, other check_... classes, and maybe even other
// calsses noncopyable? What does truly need to be copyable and why?
template<class I, class C, typename A0>
// O, F, and A-i can be none types (but C cannot).
template<class O, typename F, class C, typename A0>
class check_subcontracted_pre_post_inv : // Copyable (as * and &).
public check_pre_post_inv<C> {
// Base types as pointers because mpl::for_each will construct them.
@ -47,137 +51,124 @@ class check_subcontracted_pre_post_inv : // Copyable (as * and &).
boost::add_pointer<boost::mpl::placeholders::_1>
>::type base_ptrs;
public:
explicit check_subcontracted_pre_post_inv(
boost::contract::from from,
C const* obj,
A0 const& a0
) :
check_pre_post_inv<C>(from, obj),
c_(boost::make_shared<call>()),
a0_(a0)
{ init(); }
explicit check_subcontracted_pre_post_inv(
boost::contract::from from,
boost::shared_ptr<call> decl_call,
C const* obj,
A0 const& a0
) :
check_pre_post_inv<C>(from, decl_call, obj),
c_(decl_call),
a0_(a0)
{ init(); }
// Followings evaluate to none if F is none type.
typedef typename member_function_types<C, F>::result_type result_type;
typedef typename member_function_types<C, F>::virtual_argument_types
virt_arg_types;
typedef typename member_function_types<C, F>::property_tag property_tag;
virtual ~check_subcontracted_pre_post_inv() {}
public:
explicit check_subcontracted_pre_post_inv(boost::contract::from from,
boost::contract::virtual_* v, C* obj, A0& a0) :
check_pre_post_inv<C>(from, obj), a0_(a0)
{
if(v) {
base_call_ = true;
v_ = v; // Invariant: v_ never null if base_call_.
} else {
base_call_ = false;
if(!boost::mpl::empty<base_ptrs>::value) {
v_ = new boost::contract::virtual_(
boost::contract::virtual_::no_action);
} else v_ = 0;
}
check_base_.nest(this);
}
virtual ~check_subcontracted_pre_post_inv() {
if(!base_call_ && v_) delete v_;
}
protected:
void copy_subcontracted_oldof() {
if(this->decl_call() && this->decl_call()->action != call::copy_oldof) {
return;
}
c_.call_->action = call::copy_oldof;
boost::mpl::for_each<base_ptrs>(check_base_class_);
// No this->... here (calling func old-ofs on stack or handled by bind).
// Old values of overloading func. on stack (so no `f` for copy_oldof).
check(boost::contract::virtual_::copy_oldof);
}
void check_subcontracted_entry_inv() {
if(this->decl_call() && this->decl_call()->action !=
call::check_entry_inv) {
return;
}
c_.call_->action = call::check_entry_inv;
boost::mpl::for_each<base_ptrs>(check_base_class_);
this->check_entry_inv();
check(boost::contract::virtual_::check_entry_inv,
&check_subcontracted_pre_post_inv::check_entry_inv);
}
// Allow to throw on failure for relaxing subcontracted pre.
void check_subcontracted_pre(bool throw_on_failure = false) {
if(this->decl_call() && this->decl_call()->action != call::check_pre) {
return;
}
c_.call_->action = call::check_pre;
try {
boost::mpl::for_each<base_ptrs>(check_base_class_);
// Pre logic-or: Last check, error also throws.
this->check_pre(throw_on_failure);
} catch(no_error const&) {
// Pre logic-or: Stop at 1st no_error (thrown by callee).
if(!base_call_ || v_->action_ ==
boost::contract::virtual_::check_pre) {
try {
if(v_) {
v_->action_ = boost::contract::virtual_::check_pre;
boost::mpl::for_each<base_ptrs>(check_base_);
}
// Pre logic-or: Last check, error also throws.
this->check_pre(throw_on_failure);
} catch(no_error const&) {
// Pre logic-or: Stop at 1st no_error (thrown by callee).
}
if(base_call_) throw no_error();
}
}
void check_subcontracted_exit_inv() {
if(this->decl_call() && this->decl_call()->action !=
call::check_exit_inv) {
return;
}
c_.call_->action = call::check_exit_inv;
boost::mpl::for_each<base_ptrs>(check_base_class_);
this->check_exit_inv();
check(boost::contract::virtual_::check_exit_inv,
&check_subcontracted_pre_post_inv::check_exit_inv);
}
void check_subcontracted_post() {
if(this->decl_call() && this->decl_call()->action != call::check_post) {
return;
}
c_.call_->action = call::check_post;
boost::mpl::for_each<base_ptrs>(check_base_class_);
this->check_post();
check(boost::contract::virtual_::check_post,
&check_subcontracted_pre_post_inv::check_post);
}
bool base_call() const { return base_call_; }
private:
void init() { check_base_class_.nest(this); }
class check_base_class { // Copyable (as *).
void check(boost::contract::virtual_::action_enum a,
void (check_subcontracted_pre_post_inv::* f)() = 0) {
if(!base_call_ || v_->action_ == a) {
if(v_) {
v_->action_ = a;
boost::mpl::for_each<base_ptrs>(check_base_);
}
if(f) (this->*f)();
if(base_call_) throw no_error();
}
}
struct no_error {}; // Exception to signal OK (must not inherit).
class check_base { // Copyable (as *).
public:
explicit check_base_class() : nest_() {}
explicit check_base() : nest_() {}
void nest(check_subcontracted_pre_post_inv* n) { nest_ = n; }
template<class B>
void operator()(B*) {
typedef void result_type;
typedef boost::mpl::vector<A0 const&, boost::contract::decl>
arg_types;
call<B, result_type, arg_types>(
boost::mpl::bool_<I::template has_member_function<
B,
result_type,
arg_types,
boost::function_types::const_qualified
>::value>()
);
// TODO: If not in B, search B's inheritance graph deeply for f.
call<B>(boost::mpl::bool_<O::template
BOOST_CONTRACT_AUX_NAME1(has_member_function)<
B, result_type, virt_arg_types, property_tag
>::value>());
}
private:
template<class, typename, class>
template<class B>
void call(boost::mpl::false_ const&) {}
template<class B, typename R, class Args>
template<class B>
void call(boost::mpl::true_ const&) {
typedef typename boost::mpl::push_front<typename boost::mpl::
push_front<Args, B*>::type, R>::type base_func_types;
typedef typename boost::function_types::member_function_pointer<
base_func_types, boost::function_types::const_qualified
>::type base_func_ptr;
base_func_ptr base_func = I::template member_function_address<B,
base_func_ptr>();
BOOST_CONTRACT_AUX_DEBUG(base_func);
BOOST_CONTRACT_AUX_DEBUG(nest_);
B const* base_obj = nest_->object();
BOOST_CONTRACT_AUX_DEBUG(base_obj);
BOOST_CONTRACT_AUX_DEBUG(nest_->object());
BOOST_CONTRACT_AUX_DEBUG(nest_->v_);
BOOST_CONTRACT_AUX_DEBUG(nest_->v_->action_ !=
boost::contract::virtual_::no_action);
try {
(base_obj->*base_func)(nest_->a0_, nest_->c_);
O::template BOOST_CONTRACT_AUX_NAME1(base_call)<B, C, A0>(
nest_->object(), nest_->a0_, nest_->v_);
} catch(no_error const&) {
if(nest_->c_.call_->action == call::check_pre) {
if(nest_->v_->action_ == boost::contract::virtual_::check_pre) {
throw; // Pre logic-or: 1st no_err stops (throw to caller).
}
} catch(...) {
if(nest_->c_.call_->action == call::check_pre) {
if(nest_->v_->action_ == boost::contract::virtual_::check_pre) {
// Pre logic-or: Ignore err, possibly checks up to caller.
}
}
@ -186,9 +177,10 @@ private:
check_subcontracted_pre_post_inv* nest_;
};
boost::contract::decl c_; // Copyable (as *).
check_base_class check_base_class_; // Copyable (as *).
A0 const& a0_; // TODO: Support configurable func arity.
boost::contract::virtual_* v_;
bool base_call_;
check_base check_base_; // Copyable (as *).
A0& a0_; // TODO: Support configurable func arity.
};
} } } // namespace

17
include/boost/contract/aux_/exception.hpp
View File

@ -1,17 +0,0 @@
#ifndef BOOST_CONTRACT_AUX_EXCEPTION_HPP_
#define BOOST_CONTRACT_AUX_EXCEPTION_HPP_
#include <boost/contract/core/exception.hpp>
/** @cond */
#include <string>
/** @endcond */
namespace boost { namespace contract { namespace aux {
class no_error {}; // Must have no bases (just a tag type to signal no error).
} } } // namespace
#endif // #include guard

57
include/boost/contract/aux_/function/decl_free_function.hpp
View File

@ -1,57 +0,0 @@
#ifndef BOOST_CONTRACT_AUX_BIND_FREE_FUNCTION_HPP_
#define BOOST_CONTRACT_AUX_BIND_FREE_FUNCTION_HPP_
#include <boost/contract/core/decl.hpp>
#include <boost/contract/aux_/condition/check_base.hpp>
#include <boost/contract/aux_/call.hpp>
#include <boost/contract/aux_/exception.hpp>
#include <boost/contract/aux_/none.hpp>
/** @cond */
#include <boost/make_shared.hpp>
/** @endcond */
namespace boost { namespace contract { namespace aux {
template<typename FPtr, typename A0, typename A1>
class decl_free_function : public check_base { // Copyable (as * and &).
public:
explicit decl_free_function(FPtr f, A0 const& a0, A1 const& a1) :
c_(boost::make_shared<boost::contract::aux::call>()),
f_(f), a0_(a0), a1_(a1)
{
execute(call::copy_oldof);
execute(call::check_pre);
}
~decl_free_function() {
execute(call::check_post);
}
private:
void execute(call::action_enum a) {
c_.call_->action = a;
c_.call_->after_contract = false;
try { call(a0_, a1_); }
catch(no_error&) {} // Continue (no_error signals OK).
}
void call(none const&, none const&) { (*f_)(c_); }
template<typename T0>
void call(T0 const&, none const&) { (*f_)(a0_, c_); }
template<typename T0, typename T1>
void call(T0 const&, T1 const&) { (*f_)(a0_, a1_, c_); }
boost::contract::decl c_; // Copyable as *.
FPtr f_;
A0 const& a0_; // TODO: Support configurable func arity.
A1 const& a1_;
};
} } } // namespace
#endif // #include guard

61
include/boost/contract/aux_/function/decl_member_function.hpp
View File

@ -1,61 +0,0 @@
#ifndef BOOST_CONTRACT_AUX_BIND_MEMBER_HPP_
#define BOOST_CONTRACT_AUX_BIND_MEMBER_HPP_
#include <boost/contract/core/decl.hpp>
#include <boost/contract/aux_/condition/check_base.hpp>
#include <boost/contract/aux_/call.hpp>
#include <boost/contract/aux_/exception.hpp>
#include <boost/contract/aux_/none.hpp>
/** @cond */
#include <boost/make_shared.hpp>
/** @endcond */
namespace boost { namespace contract { namespace aux {
template<typename FPtr, class C, typename A0, typename A1>
class decl_member_function : public check_base { // Copyable (as * and &).
public:
explicit decl_member_function(FPtr f, C const* obj, A0 const& a0,
A1 const& a1) :
c_(boost::make_shared<boost::contract::aux::call>()),
f_(f), obj_(obj), a0_(a0), a1_(a1)
{
execute(call::copy_oldof);
execute(call::check_entry_inv);
execute(call::check_pre);
}
~decl_member_function() {
execute(call::check_exit_inv);
execute(call::check_post);
}
private:
void execute(call::action_enum a) {
c_.call_->action = a;
c_.call_->after_contract = false;
try { call(a0_, a1_); }
catch(no_error&) {} // Continue (no_error signals OK).
}
void call(none const&, none const&) { (obj_->*f_)(c_); }
template<typename T0>
void call(T0 const&, none const&) { (obj_->*f_)(a0_, c_); }
template<typename T0, typename T1>
void call(T0 const&, T1 const&) { (obj_->*f_)(a0_, a1_, c_); }
boost::contract::decl c_; // Copy as ptr.
FPtr f_;
C const* obj_;
A0 const& a0_; // TODO: Support configurable func arity.
A1 const& a1_;
};
} } } // namespace
#endif // #include guard

37
include/boost/contract/aux_/function/public_member.hpp
View File

@ -2,7 +2,7 @@
#ifndef BOOST_CONTRACT_AUX_PUBLIC_MEMBER_HPP_
#define BOOST_CONTRACT_AUX_PUBLIC_MEMBER_HPP_
#include <boost/contract/aux_/call.hpp>
#include <boost/contract/core/virtual.hpp>
#include <boost/contract/aux_/condition/check_subcontracted_pre_post_inv.hpp>
/** @cond */
#include <boost/shared_ptr.hpp>
@ -11,43 +11,34 @@
namespace boost { namespace contract { namespace aux {
template<class I, class C, typename A0>
class public_member : public boost::contract::aux::
check_subcontracted_pre_post_inv<I, C, A0> {
template<class O, typename F, class C, typename A0>
class public_member : public check_subcontracted_pre_post_inv<O, F, C, A0> {
public:
explicit public_member(C const* obj, A0 const& a0) :
boost::contract::aux::check_subcontracted_pre_post_inv<I, C, A0>(
boost::contract::from_public_member, obj, a0)
{ init(); }
explicit public_member(boost::shared_ptr<boost::contract::aux::call> call,
C const* obj, A0 const& a0) :
boost::contract::aux::check_subcontracted_pre_post_inv<I, C, A0>(
boost::contract::from_public_member, call, obj, a0)
{ init(); }
private:
void init() {
explicit public_member(boost::contract::virtual_* v, C* obj, A0& a0) :
check_subcontracted_pre_post_inv<O, F, C, A0>(
boost::contract::from_public_member, v, obj, a0)
{
this->copy_subcontracted_oldof();
this->check_subcontracted_entry_inv();
// Throw (so not in dtor).
if(this->decl_call()) this->check_subcontracted_exit_inv();
if(this->base_call()) { // Throw no_error so not in dtor.
this->check_subcontracted_exit_inv();
}
}
private:
void pre_available() /* override */ { this->check_subcontracted_pre(); }
void post_available() /* override */ {
// Body did not throw.
if(this->decl_call() && !std::uncaught_exception()) {
// Throw no_error (so not in dtor).
this->check_subcontracted_post();
if(this->base_call() && !std::uncaught_exception()) {
this->check_subcontracted_post(); // Throw no_error so not in dtor.
}
}
public:
~public_member() {
// Body didn't throw.
if(!this->decl_call() && !std::uncaught_exception()) {
if(!this->base_call() && !std::uncaught_exception()) {
this->check_subcontracted_exit_inv();
this->check_subcontracted_post();
}

62
include/boost/contract/aux_/type_traits/member_function_types.hpp Normal file
View File

@ -0,0 +1,62 @@
#ifndef BOOST_CONTRACT_AUX_MEMBER_FUNCTION_TYPES_HPP_
#define BOOST_CONTRACT_AUX_MEMBER_FUNCTION_TYPES_HPP_
#include <boost/contract/core/virtual.hpp>
#include <boost/contract/aux_/none.hpp>
#include <boost/function_types/result_type.hpp>
#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/property_tags.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/back.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/identity.hpp>
namespace boost { namespace contract { namespace aux {
template<class C, typename F>
struct member_function_types {
typedef typename boost::function_types::result_type<F>::type result_type;
// Never include leading class type.
typedef typename boost::mpl::pop_front<typename boost::function_types::
parameter_types<F>::type>::type argument_types;
// Always include trailing virtual_* type.
typedef typename boost::mpl::if_<boost::is_same<typename boost::
mpl::back<argument_types>::type, boost::contract::virtual_*>,
boost::mpl::identity<argument_types>
,
boost::mpl::push_back<argument_types, boost::contract::virtual_*>
>::type::type virtual_argument_types;
typedef typename boost::mpl::if_<boost::mpl::and_<boost::is_const<C>,
boost::is_volatile<C> >,
boost::function_types::cv_qualified
, typename boost::mpl::if_<boost::is_const<C>,
boost::function_types::const_non_volatile
, typename boost::mpl::if_<boost::is_volatile<C>,
boost::function_types::volatile_non_const
,
boost::function_types::null_tag
>::type>::type>::type property_tag;
};
// Also handles none type.
template<class C>
struct member_function_types<C, none> {
typedef none result_type;
typedef none argument_types;
typedef none virtual_argument_types;
typedef none property_tag;
};
} } } // namespace
#endif // #include guard

83
include/boost/contract/core/decl.hpp
View File

@ -1,83 +0,0 @@
#ifndef BOOST_CONTRACT_DECL_HPP_
#define BOOST_CONTRACT_DECL_HPP_
/** @file */
#include <boost/contract/aux_/call.hpp>
/** @cond */
#include <boost/shared_ptr.hpp>
/** @endcond */
namespace boost {
namespace contract {
class set_precondition_postcondition;
class set_postcondition_only;
namespace aux {
template<class, class, typename>
class check_subcontracted_pre_post_inv;
template<typename, typename, typename>
class decl_free_function;
template<typename, class, typename, typename>
class decl_member_function;
}
}
}
namespace boost { namespace contract {
class decl {
public:
// Nothing here (opaque object that users cannot directly use or create).
private:
explicit decl(boost::shared_ptr<boost::contract::aux::call> call) :
call_(call) {}
// TODO: DO I need the copy ctor?
decl(decl const& other) : call_(other.call_) {} // Shallow ptr copy.
decl& operator=(decl const&); // No copy operator.
boost::shared_ptr<aux::call> call_;
// Friendship used to limit lib's public API.
friend bool copy_old(decl const&);
friend class old;
template<class C>
friend set_postcondition_only constructor(decl const&, C const*);
template<class C>
friend set_postcondition_only destructor(decl const&, C const*);
template<class C>
friend set_precondition_postcondition public_member(decl const&, C const*);
template<class, class C, typename A0>
friend set_precondition_postcondition public_member(decl const&, C const*,
A0 const&);
friend set_precondition_postcondition protected_member(decl const&);
friend set_precondition_postcondition private_member(decl const&);
friend set_precondition_postcondition free_function(decl const&);
template<class, class, typename>
friend class boost::contract::aux::check_subcontracted_pre_post_inv;
template<typename, typename, typename>
friend class boost::contract::aux::decl_free_function;
template<typename, class, typename, typename>
friend class boost::contract::aux::decl_member_function;
};
} } // namespace
#endif // #include guard

44
include/boost/contract/core/set_nothing.hpp
View File

@ -4,56 +4,32 @@
/** @file */
#include <boost/contract/aux_/condition/check_base.hpp>
#include <boost/contract/aux_/condition/check_pre_post.hpp>
/** @cond */
#include <boost/shared_ptr.hpp>
/** @endcond */
namespace boost {
namespace contract {
class decl;
}
}
namespace boost { namespace contract {
// TODO: Make sure all friend declarations are at bottom of public if part of
// public API, or at bottom of private if part of private API.
// TODO: Do I need to store contracts as shared_ptr or unique_ptr is sufficient?
class set_nothing {
// Friendship used to limit lib's public API.
friend class var;
friend class set_precondition_only;
friend class set_postcondition_only;
friend set_nothing decl_function(void (* f)(decl));
template<typename A0>
friend set_nothing decl_function(A0 const&, void (* f)(A0 const&, decl));
template<typename A0, typename A1>
friend set_nothing decl_function(A0 const&, A1 const&,
void (* f)(A0 const&, A1 const&, decl));
template<class C>
friend set_nothing decl_function(C const*, void (C::* f)(decl) const);
template<class C, typename A0>
friend set_nothing decl_function(C const*, A0 const&,
void (C::* f)(A0 const&, decl) const);
template<class C, typename A0, typename A1>
friend set_nothing bind(C const*, A0 const&, A1 const&,
void (C::* f)(A0 const&, A1 const&, decl) const);
public:
// No set function members here.
private:
explicit set_nothing(boost::shared_ptr<
boost::contract::aux::check_base> check) : check_(check) {}
boost::contract::aux::check_pre_post> check) : check_(check) {}
boost::shared_ptr<boost::contract::aux::check_base> check_;
boost::shared_ptr<boost::contract::aux::check_pre_post> check_;
// Friendship used to limit library's public API.
friend class scoped;
friend class set_precondition_only;
friend class set_postcondition_only;
};
} } // namespace

23
include/boost/contract/core/set_postcondition_only.hpp
View File

@ -5,7 +5,6 @@
/** @file */
#include <boost/contract/core/set_nothing.hpp>
#include <boost/contract/core/decl.hpp>
#include <boost/contract/aux_/condition/check_pre_post.hpp>
/** @cond */
#include <boost/shared_ptr.hpp>
@ -14,22 +13,6 @@
namespace boost { namespace contract {
class set_postcondition_only {
// Friendship used to limit lib's public API.
friend class var;
friend class set_precondition_postcondition;
template<class C>
friend set_postcondition_only constructor(C const*);
template<class C>
friend set_postcondition_only constructor(decl const&, C const*);
template<class C>
friend set_postcondition_only destructor(C const*);
template<class C>
friend set_postcondition_only destructor(decl const&, C const*);
public:
template<typename F>
set_nothing postcondition(F const& f) {
@ -41,9 +24,11 @@ private:
explicit set_postcondition_only(boost::shared_ptr<
boost::contract::aux::check_pre_post> check) : check_(check) {}
// TODO: Can I use unique_ptr or some other smart ptr with less overhead
// than shared_ptr for old values, here, and everywhere?
boost::shared_ptr<boost::contract::aux::check_pre_post> check_;
// Friendship used to limit library's public API.
friend class scoped;
friend class set_precondition_postcondition;
};
} } // namespace

3
include/boost/contract/core/set_precondition_only.hpp
View File

@ -29,6 +29,9 @@ private:
boost::contract::aux::check_pre_post> check) : check_(check) {}
boost::shared_ptr<boost::contract::aux::check_pre_post> check_;
// Friendship used to limit library's public API.
friend class scoped;
};
} } // namespace

50
include/boost/contract/core/set_precondition_postcondition.hpp
View File

@ -6,19 +6,21 @@
#include <boost/contract/core/set_precondition_only.hpp>
#include <boost/contract/core/set_postcondition_only.hpp>
#include <boost/contract/core/decl.hpp>
#include <boost/contract/aux_/condition/check_pre_post.hpp>
/** @cond */
#include <boost/shared_ptr.hpp>
/** @endcond */
// TODO: Read what's the best practise for namespace qualification and use it.
namespace boost {
namespace contract {
class virtual_;
}
}
namespace boost { namespace contract {
// TODO: Read what's the best practise for namespace qualification...
// I can even write an example to test if concize namespace qualification
// gives problem when same func/class/typedef/etc in different namespaces.
// If so, I must always fully qualify...
class set_precondition_postcondition {
public:
template<typename F>
@ -38,29 +40,25 @@ private:
boost::contract::aux::check_pre_post> check) : check_(check) {}
boost::shared_ptr<boost::contract::aux::check_pre_post> check_;
// Friendship used to limit lib's public API.
friend class var;
// Friendship used to limit library's public API.
friend class scoped;
template<class C>
friend set_precondition_postcondition public_member(decl const&, C const*);
template<class, class C, typename A0>
friend set_precondition_postcondition public_member(C const*, A0 const&);
template<class, class C, typename A0>
friend set_precondition_postcondition public_member(decl const&, C const*,
A0 const&);
friend set_precondition_postcondition protected_member();
friend set_precondition_postcondition protected_member(decl const&);
friend set_precondition_postcondition private_member();
friend set_precondition_postcondition private_member(decl const&);
friend set_precondition_postcondition free_function();
friend set_precondition_postcondition free_function(decl const&);
friend set_precondition_postcondition public_member(C*);
template<class C>
friend set_precondition_postcondition public_member(virtual_*, C*);
// arity = 0
template<class O, typename F, class C>
friend set_precondition_postcondition public_member(F, C*);
template<class O, typename F, class C>
friend set_precondition_postcondition public_member(virtual_*, F, C*);
// arity = 1
template<class O, typename F, class C, typename A0>
friend set_precondition_postcondition public_member(F, C*, A0&);
template<class O, typename F, class C, typename A0>
friend set_precondition_postcondition public_member(virtual_*, F, C*, A0&);
// TODO: Support configurable arity.
};
} } // namespace

51
include/boost/contract/core/virtual.hpp Normal file
View File

@ -0,0 +1,51 @@
#ifndef BOOST_CONTRACT_VIRTUAL_HPP_
#define BOOST_CONTRACT_VIRTUAL_HPP_
/** @cond */
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <queue>
/** @endcond */
namespace boost {
namespace contract {
namespace aux {
template<class, typename, class, typename>
class check_subcontracted_pre_post_inv;
}
}
}
namespace boost { namespace contract {
class virtual_ : private boost::noncopyable { // Non copyable (no queue copy).
// No public API (so users cannot use it directly).
private:
enum action_enum {
// virtual_ always hold/passed by ptr so null ptr used for user call.
no_action,
copy_oldof,
check_entry_inv,
check_pre,
check_post,
check_exit_inv
};
explicit virtual_(action_enum a) : action_(a), old_values_() {}
action_enum action_;
std::queue<boost::shared_ptr<void> > old_values_;
// Friendship used to limit library's public API.
friend bool copy_old(virtual_*);
friend class old;
template<class, typename, class, typename>
friend class boost::contract::aux::check_subcontracted_pre_post_inv;
};
} } // namespace
#endif // #include guard

92
include/boost/contract/decl_function.hpp
View File

@ -1,92 +0,0 @@
#ifndef BOOST_CONTRACT_DECL_FUNCTION_HPP_
#define BOOST_CONTRACT_DECL_FUNCTION_HPP_
/** @file */
#include <boost/contract/core/decl.hpp>
#include <boost/contract/core/set_nothing.hpp>
#include <boost/contract/aux_/function/decl_free_function.hpp>
#include <boost/contract/aux_/function/decl_member_function.hpp>
#include <boost/contract/aux_/none.hpp>
/** @cond */
#include <boost/make_shared.hpp>
/** @endcond */
namespace boost { namespace contract {
// NOTE: `f` last arg otherwise some compilers (MSVC) cannot always deduce it.
// TODO: Support configurable function arity.
// Free function.
set_nothing decl_function(void (* f)(decl)) {
return set_nothing(boost::make_shared<
boost::contract::aux::decl_free_function<
void (*)(decl),
boost::contract::aux::none, boost::contract::aux::none
>
>(f, boost::contract::aux::none::value, boost::contract::aux::none::value));
}
template<typename A0>
set_nothing decl_function(A0 const& a0, void (* f)(A0 const&, decl)) {
return set_nothing(boost::make_shared<
boost::contract::aux::decl_free_function<
void (*)(A0 const&, decl),
A0, boost::contract::aux::none
>
>(f, a0, boost::contract::aux::none::value));
}
template<typename A0, typename A1>
set_nothing decl_function(A0 const& a0, A1 const& a1,
void (* f)(A0 const&, A1 const&, decl)) {
return set_nothing(boost::make_shared<
boost::contract::aux::decl_free_function<
void (*)(A0 const&, A1 const&, decl),
A0, A1
>
>(f, a0, a1));
}
// Member function (constructor and destructor included).
template<class C>
set_nothing decl_function(C const* obj, void (C::* f)(decl) const) {
return set_nothing(boost::make_shared<
boost::contract::aux::decl_member_function<
void (C::*)(decl) const,
C, boost::contract::aux::none, boost::contract::aux::none
>
>(f, obj, boost::contract::aux::none::value,
boost::contract::aux::none::value));
}
template<class C, typename A0>
set_nothing decl_function(C const* obj, A0 const& a0,
void (C::* f)(A0 const&, decl) const) {
return set_nothing(boost::make_shared<
boost::contract::aux::decl_member_function<
void (C::*)(A0 const&, decl) const,
C, A0, boost::contract::aux::none
>
>(f, obj, a0, boost::contract::aux::none::value));
}
template<class C, typename A0, typename A1>
set_nothing decl_function(C const* obj, A0 const& a0, A1 const& a1,
void (C::* f)(A0 const&, A1 const&, decl) const) {
return set_nothing(boost::make_shared<
boost::contract::aux::decl_member_function<
void (C::*)(A0 const&, A1 const&, decl) const,
C, A0, A1
>
>(f, obj, a0, a1));
}
} } // namespace
#endif // #include guard

32
include/boost/contract/introspect.hpp
View File

@ -1,32 +0,0 @@
#ifndef BOOST_CONTRACT_INTROSPECT_HPP_
#define BOOST_CONTRACT_INTROSPECT_HPP_
/** @file */
#include <boost/contract/aux_/type_traits/introspection.hpp>
#include <boost/contract/aux_/name.hpp>
/** @cond */
#include <boost/preprocessor/cat.hpp>
/** @endcond */
/* PUBLIC */
#define BOOST_CONTRACT_INTROSPECT(function_name) \
BOOST_CONTRACT_INTROSPECT_TRAIT(BOOST_PP_CAT(introspect_, function_name), \
function_name)
#define BOOST_CONTRACT_INTROSPECT_TRAIT(trait_name, function_name) \
struct trait_name { \
BOOST_CONTRACT_AUX_INTROSPECTION_HAS_MEMBER_FUNCTION( \
has_member_function, function_name) \
\
template<class BOOST_CONTRACT_AUX_NAME1(C), \
typename BOOST_CONTRACT_AUX_NAME1(F)> \
static BOOST_CONTRACT_AUX_NAME1(F) member_function_address() { \
return &BOOST_CONTRACT_AUX_NAME1(C)::function_name; \
} \
};
#endif // #include guard

36
include/boost/contract/oldof.hpp
View File

@ -4,8 +4,7 @@
/** @file */
#include <boost/contract/core/decl.hpp>
#include <boost/contract/aux_/call.hpp>
#include <boost/contract/core/virtual.hpp>
#include <boost/contract/aux_/debug.hpp>
/** @cond */
#include <boost/make_shared.hpp>
@ -47,9 +46,9 @@ BOOST_CONTRACT_ERROR_macro_OLDOF_has_invalid_number_of_arguments_, \
))
#define BOOST_CONTRACT_ERROR_macro_OLDOF_has_invalid_number_of_arguments_2( \
c, value) \
BOOST_CONTRACT_OLDOF_AUTO_(value)(boost::contract::old(c, \
boost::contract::copy_old(c) ? (value) : boost::contract::old() \
v, value) \
BOOST_CONTRACT_OLDOF_AUTO_(value)(boost::contract::old(v, \
boost::contract::copy_old(v) ? (value) : boost::contract::old() \
))
#ifdef BOOST_NO_CXX11_AUTO_DECLARATIONS
@ -77,20 +76,19 @@ bool copy_old() {
#endif
}
bool copy_old(decl const& c) {
bool copy_old(virtual_* v) {
#ifdef BOOST_CONTRACT_CONFIG_NO_POSTCONDITIONS
return false; // Post checking disabled, so never copy old values.
#else
return c.call_ && c.call_->action == boost::contract::aux::call::copy_oldof;
return !v || v->action_ == boost::contract::virtual_::copy_oldof;
#endif
}
class old {
class old { // Copyable (as *).
public:
explicit old() : decl_call_(), value_() {}
explicit old() : v_(0), value_() {}
explicit old(decl const& c, old const& other) :
decl_call_(c.call_), value_(other.value_) {}
explicit old(virtual_* v, old const& other) : v_(v), value_(other.value_) {}
template<typename T>
/* implicit */ old(T const& old_value) :
@ -103,23 +101,21 @@ public:
template<typename T>
operator boost::shared_ptr<T const>() {
if(!decl_call_) {
if(!v_) {
BOOST_CONTRACT_AUX_DEBUG(value_);
boost::shared_ptr<T const> old_value =
boost::static_pointer_cast<T const>(value_);
BOOST_CONTRACT_AUX_DEBUG(old_value);
return old_value;
} else if(decl_call_->action ==
boost::contract::aux::call::copy_oldof) {
} else if(v_->action_ == boost::contract::virtual_::copy_oldof) {
BOOST_CONTRACT_AUX_DEBUG(value_);
decl_call_->old_values.push(value_);
v_->old_values_.push(value_);
return boost::shared_ptr<T const>();
} else if(decl_call_->action ==
boost::contract::aux::call::check_post) {
} else if(v_->action_ == boost::contract::virtual_::check_post) {
BOOST_CONTRACT_AUX_DEBUG(!value_);
boost::shared_ptr<void> value = decl_call_->old_values.front();
boost::shared_ptr<void> value = v_->old_values_.front();
BOOST_CONTRACT_AUX_DEBUG(value);
decl_call_->old_values.pop();
v_->old_values_.pop();
boost::shared_ptr<T const> old_value =
boost::static_pointer_cast<T const>(value);
BOOST_CONTRACT_AUX_DEBUG(old_value);
@ -130,7 +126,7 @@ public:
}
private:
boost::shared_ptr<boost::contract::aux::call> decl_call_;
virtual_* v_;
boost::shared_ptr<void> value_;
};

42
include/boost/contract/override.hpp Normal file
View File

@ -0,0 +1,42 @@
#ifndef BOOST_CONTRACT_OVERRIDE_HPP_
#define BOOST_CONTRACT_OVERRIDE_HPP_
/** @file */
#include <boost/contract/core/virtual.hpp>
#include <boost/contract/aux_/type_traits/introspection.hpp>
#include <boost/contract/aux_/name.hpp>
/** @cond */
#include <boost/preprocessor/cat.hpp>
/** @endcond */
/* PUBLIC */
#define BOOST_CONTRACT_OVERRIDE(f) \
BOOST_CONTRACT_OVERRIDE_TRAIT(BOOST_PP_CAT(override_, f), f)
#define BOOST_CONTRACT_OVERRIDE_TRAIT(trait, f) \
struct trait { \
BOOST_CONTRACT_AUX_INTROSPECTION_HAS_MEMBER_FUNCTION( \
BOOST_CONTRACT_AUX_NAME1(has_member_function), f) \
\
template< \
class BOOST_CONTRACT_AUX_NAME1(B), \
class BOOST_CONTRACT_AUX_NAME1(C), \
typename BOOST_CONTRACT_AUX_NAME1(A0) \
> \
static void BOOST_CONTRACT_AUX_NAME1(base_call)( \
BOOST_CONTRACT_AUX_NAME1(C)* BOOST_CONTRACT_AUX_NAME1(obj), \
BOOST_CONTRACT_AUX_NAME1(A0)& BOOST_CONTRACT_AUX_NAME1(a0), \
boost::contract::virtual_* BOOST_CONTRACT_AUX_NAME1(v) \
) { \
BOOST_CONTRACT_AUX_NAME1(obj)->BOOST_CONTRACT_AUX_NAME1(B)::f( \
BOOST_CONTRACT_AUX_NAME1(a0), \
BOOST_CONTRACT_AUX_NAME1(v) \
); \
} \
};
#endif // #include guard

91
include/boost/contract/public_member.hpp
View File

@ -5,7 +5,7 @@
/** @file */
#include <boost/contract/core/set_precondition_postcondition.hpp>
#include <boost/contract/core/decl.hpp>
#include <boost/contract/core/virtual.hpp>
#include <boost/contract/aux_/function/public_member.hpp>
#include <boost/contract/aux_/none.hpp>
/** @cond */
@ -14,40 +14,89 @@
namespace boost { namespace contract {
// For non-virtual of class with no bases.
template<class C>
set_precondition_postcondition public_member(C* obj) {
return set_precondition_postcondition(boost::make_shared<
boost::contract::aux::public_member<
boost::contract::aux::none,
boost::contract::aux::none,
C,
boost::contract::aux::none
>
>(0, obj, boost::contract::aux::none::value));
}
// For virtual members of class with no bases.
template<class C>
set_precondition_postcondition public_member(virtual_* v, C* obj) {
return set_precondition_postcondition(boost::make_shared<
boost::contract::aux::public_member<
boost::contract::aux::none,
boost::contract::aux::none,
C,
boost::contract::aux::none
>
>(v, obj, boost::contract::aux::none::value));
}
// TODO: Support configurable function arity.
// arity = 0
template<class C>
set_precondition_postcondition public_member(C const* obj) {
// For non-virtual members of class with bases.
template<class O, typename F, class C>
set_precondition_postcondition public_member(F, C* obj) {
return set_precondition_postcondition(boost::make_shared<
boost::contract::aux::public_member<boost::contract::aux::none, C,
boost::contract::aux::none>
>(obj, boost::contract::aux::none::value));
boost::contract::aux::public_member<
O,
F,
C,
boost::contract::aux::none
>
>(0, obj, boost::contract::aux::none::value));
}
template<class C>
set_precondition_postcondition public_member(decl const& c, C const* obj) {
// For virtual members of class with bases.
template<class O, typename F, class C>
set_precondition_postcondition public_member(virtual_* v, F, C* obj) {
return set_precondition_postcondition(boost::make_shared<
boost::contract::aux::public_member<boost::contract::aux::none, C,
boost::contract::aux::none>
>(c.call_, obj, boost::contract::aux::none::value));
boost::contract::aux::public_member<
O,
F,
C,
boost::contract::aux::none
>
>(v, obj, boost::contract::aux::none::value));
}
template<class I, class C, typename A0>
set_precondition_postcondition public_member(C const* obj,
A0 const& a0) {
// arity = 1
template<class O, typename F, class C, typename A0>
set_precondition_postcondition public_member(F, C* obj, A0& a0) {
return set_precondition_postcondition(boost::make_shared<
boost::contract::aux::public_member<I, C, A0>
>(obj, a0));
boost::contract::aux::public_member<
O,
F,
C,
A0
>
>(0, obj, a0));
}
template<class I, class C, typename A0>
set_precondition_postcondition public_member(decl const& c, C const* obj,
A0 const& a0) {
template<class O, typename F, class C, typename A0>
set_precondition_postcondition public_member(virtual_* v, F, C* obj, A0& a0) {
return set_precondition_postcondition(boost::make_shared<
boost::contract::aux::public_member<I, C, A0>
>(c.call_, obj, a0));
boost::contract::aux::public_member<
O,
F,
C,
A0
>
>(v, obj, a0));
}
// TODO: Support configurable arity.
} } // namespace
#endif // #include guard

20
include/boost/contract/var.hpp → include/boost/contract/scoped.hpp
View File

@ -1,6 +1,6 @@
#ifndef BOOST_CONTRACT_VAR_HPP_
#define BOOST_CONTRACT_VAR_HPP_
#ifndef BOOST_CONTRACT_SCOPED_HPP_
#define BOOST_CONTRACT_SCOPED_HPP_
/** @file */
@ -8,31 +8,31 @@
#include <boost/contract/core/set_precondition_only.hpp>
#include <boost/contract/core/set_postcondition_only.hpp>
#include <boost/contract/core/set_nothing.hpp>
#include <boost/contract/aux_/condition/check_base.hpp>
#include <boost/contract/aux_/condition/check_pre_post.hpp>
/** @cond */
#include <boost/shared_ptr.hpp>
/** @endcond */
namespace boost { namespace contract {
class var { // Copyable (as shallow *).
class scoped { // Copyable (as shallow *).
public:
// All implicit to allow `var contract = ...`.
// All implicit to allow `scoped c = ...`.
/* implicit */ var(set_precondition_postcondition const& contract) :
/* implicit */ scoped(set_precondition_postcondition const& contract) :
check_(contract.check_) {}
/* implicit */ var(set_precondition_only const& contract) :
/* implicit */ scoped(set_precondition_only const& contract) :
check_(contract.check_) {}
/* implicit */ var(set_postcondition_only const& contract) :
/* implicit */ scoped(set_postcondition_only const& contract) :
check_(contract.check_) {}
/* implicit */ var(set_nothing const& contract) :
/* implicit */ scoped(set_nothing const& contract) :
check_(contract.check_) {}
private:
boost::shared_ptr<aux::check_base> check_;
boost::shared_ptr<boost::contract::aux::check_pre_post> check_;
};
} } // namespace

87
test/public_member/bases.cpp
View File

@ -3,12 +3,11 @@
#include "../aux_/oteststream.hpp"
#include <boost/contract/public_member.hpp>
#include <boost/contract/decl_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/oldof.hpp>
#include <boost/contract/var.hpp>
#include <boost/contract/assert.hpp>
#include <boost/contract/introspect.hpp>
#include <boost/contract/oldof.hpp>
#include <boost/contract/scoped.hpp>
#include <boost/contract/override.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <string>
@ -26,25 +25,28 @@ struct t {
std::string z;
t() : z("") { z.push_back(Id); }
void f(std::string const& s, boost::contract::decl c) const {
boost::shared_ptr<std::string const> old_u = BOOST_CONTRACT_OLDOF(c, z);
boost::shared_ptr<std::string const> old_s = BOOST_CONTRACT_OLDOF(c, s);
boost::contract::var contract = boost::contract::public_member(c, this)
.precondition([&] {
out << Id << "::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s != "");
// BOOST_CONTRACT_ASSERT(false);
})
.postcondition([&] {
out << Id << "::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(z == *old_u + *old_s);
BOOST_CONTRACT_ASSERT(s.find(*old_u) != std::string::npos);
})
;
}
// Test pure virtual (=> decl).
virtual void f(std::string& s) = 0;
virtual std::string f(std::string& s, boost::contract::virtual_* v = 0);
};
template<char Id>
std::string t<Id>::f(std::string& s, boost::contract::virtual_* v) {
boost::shared_ptr<std::string const> old_u = BOOST_CONTRACT_OLDOF(v, z);
boost::shared_ptr<std::string const> old_s = BOOST_CONTRACT_OLDOF(v, s);
boost::contract::scoped c = boost::contract::public_member(v, this)
.precondition([&] {
out << Id << "::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s != "");
// BOOST_CONTRACT_ASSERT(false);
})
.postcondition([&] {
out << Id << "::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(z == *old_u + *old_s);
BOOST_CONTRACT_ASSERT(s.find(*old_u) != std::string::npos);
})
;
return "";
}
struct c
#define BASES public t<'d'>, protected t<'p'>, private t<'q'>, public t<'e'>
@ -62,11 +64,13 @@ struct c
std::string y;
c() : y("c") {}
void f(std::string const& s, boost::contract::decl c) const {
boost::shared_ptr<std::string const> old_y = BOOST_CONTRACT_OLDOF(c, y);
boost::shared_ptr<std::string const> old_s = BOOST_CONTRACT_OLDOF(c, s);
boost::contract::var contract = boost::contract::public_member<
introspect_f>(c, this, s)
// Test both overriding (=> introspect) and virtual (=> decl).
virtual std::string f(std::string& s, boost::contract::virtual_* v = 0)
/* override */ {
boost::shared_ptr<std::string const> old_y = BOOST_CONTRACT_OLDOF(v, y);
boost::shared_ptr<std::string const> old_s = BOOST_CONTRACT_OLDOF(v, s);
boost::contract::scoped c = boost::contract::public_member<
override_f>(v, &c::f, this, s)
.precondition([&] {
out << "c::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s != "");
@ -78,19 +82,15 @@ struct c
BOOST_CONTRACT_ASSERT(s.find(*old_y) != std::string::npos);
})
;
}
// Test both overriding (=> introspect) and virtual (=> decl).
virtual void f(std::string& s) /* override */ {
boost::contract::var contract = boost::contract::decl_function(
this, s, &c::f);
out << "c::f::body" << std::endl;
return s;
}
BOOST_CONTRACT_INTROSPECT(f)
BOOST_CONTRACT_OVERRIDE(f)
};
// Test not (fully) contracted base is not part of subcontracting.
struct b {
virtual void f(std::string&) = 0; // No contract.
virtual std::string f(std::string& s) { return s; } // No contract.
};
// Test public member with both non-contracted and contracted bases.
@ -111,17 +111,21 @@ struct a
a() : x("a") {}
// Test overriding (=> introspect).
void f(std::string& s) /* override */ {
boost::shared_ptr<std::string const> old_x = BOOST_CONTRACT_OLDOF(x);
boost::shared_ptr<std::string const> old_s = BOOST_CONTRACT_OLDOF(s);
boost::contract::var contract = boost::contract::public_member<
introspect_f>(this, s)
// TODO: Do I need this virtual_* or not? ... would a polymorphic cass to
// c still call into this f impl if virtual_* is not here? I'd think so...
std::string f(std::string& s, boost::contract::virtual_* v = 0)
/* override */ {
std::string result = "";
boost::shared_ptr<std::string const> old_x = BOOST_CONTRACT_OLDOF(v, x);
boost::shared_ptr<std::string const> old_s = BOOST_CONTRACT_OLDOF(v, s);
boost::contract::scoped c = boost::contract::public_member<
override_f>(v, &a::f, this, s)
.precondition([&] {
out << "a::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s != "");
})
.postcondition([&] {
out << "a::f::post" << std::endl;
out << "a::f::post ** " << result << std::endl;
BOOST_CONTRACT_ASSERT(x == *old_x + *old_s);
BOOST_CONTRACT_ASSERT(s.find(*old_x) != std::string::npos);
})
@ -144,8 +148,10 @@ struct a
save = t<'e'>::z;
t<'e'>::z += save_s;
s += save;
return result = save_s;
}
BOOST_CONTRACT_INTROSPECT(f)
BOOST_CONTRACT_OVERRIDE(f)
};
int main() {
@ -156,6 +162,7 @@ int main() {
std::cout << aa.x << std::endl;
std::cout << aa.y << std::endl;
std::cout << aa.t<'d'>::z << std::endl;
std::cout << aa.t<'e'>::z << std::endl;
//BOOST_TEST_EQ(aa.val(), 456);
//BOOST_TEST_EQ(i, 123);

164
test/public_member/bases_decl.cpp Normal file
View File

@ -0,0 +1,164 @@
// Test public member subcontracting.
#include "../aux_/oteststream.hpp"
#include <boost/contract/public_member.hpp>
#include <boost/contract/decl_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/oldof.hpp>
#include <boost/contract/var.hpp>
#include <boost/contract/assert.hpp>
#include <boost/contract/introspect.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <string>
boost::contract::aux::test::oteststream out;
template<char Id>
struct t {
void invariant() const {
out << Id << "::inv" << std::endl;
BOOST_CONTRACT_ASSERT(z != "");
}
static void static_invariant() { out << Id << "::static_inv" << std::endl; }
std::string z;
t() : z("") { z.push_back(Id); }
void f(std::string const& s, boost::contract::decl c) const {
boost::shared_ptr<std::string const> old_u = BOOST_CONTRACT_OLDOF(c, z);
boost::shared_ptr<std::string const> old_s = BOOST_CONTRACT_OLDOF(c, s);
boost::contract::var contract = boost::contract::public_member(c, this)
.precondition([&] {
out << Id << "::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s != "");
// BOOST_CONTRACT_ASSERT(false);
})
.postcondition([&] {
out << Id << "::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(z == *old_u + *old_s);
BOOST_CONTRACT_ASSERT(s.find(*old_u) != std::string::npos);
})
;
}
// Test pure virtual (=> decl).
virtual void f(std::string& s) = 0;
};
struct c
#define BASES public t<'d'>, protected t<'p'>, private t<'q'>, public t<'e'>
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
void invariant() const {
out << "c::inv" << std::endl;
BOOST_CONTRACT_ASSERT(y != "");
}
static void static_invariant() { out << "c::static_inv" << std::endl; }
std::string y;
c() : y("c") {}
void f(std::string const& s, boost::contract::decl c) const {
boost::shared_ptr<std::string const> old_y = BOOST_CONTRACT_OLDOF(c, y);
boost::shared_ptr<std::string const> old_s = BOOST_CONTRACT_OLDOF(c, s);
boost::contract::var contract = boost::contract::public_member<
introspect_f>(c, this, s)
.precondition([&] {
out << "c::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s != "");
// BOOST_CONTRACT_ASSERT(false);
})
.postcondition([&] {
out << "c::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(y == *old_y + *old_s);
BOOST_CONTRACT_ASSERT(s.find(*old_y) != std::string::npos);
})
;
}
// Test both overriding (=> introspect) and virtual (=> decl).
virtual void f(std::string& s) /* override */ {
boost::contract::var contract = boost::contract::decl_function(
this, s, &c::f);
out << "c::f::body" << std::endl;
}
BOOST_CONTRACT_INTROSPECT(f)
};
// Test not (fully) contracted base is not part of subcontracting.
struct b {
virtual void f(std::string&) = 0; // No contract.
};
// Test public member with both non-contracted and contracted bases.
struct a
#define BASES public b, public c
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
void invariant() const {
out << "a::inv" << std::endl;
BOOST_CONTRACT_ASSERT(x != "");
}
static void static_invariant() { out << "a::static_inv" << std::endl; }
std::string x;
a() : x("a") {}
// Test overriding (=> introspect).
void f(std::string& s) /* override */ {
boost::shared_ptr<std::string const> old_x = BOOST_CONTRACT_OLDOF(x);
boost::shared_ptr<std::string const> old_s = BOOST_CONTRACT_OLDOF(s);
boost::contract::var contract = boost::contract::public_member<
introspect_f>(this, s)
.precondition([&] {
out << "a::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s != "");
})
.postcondition([&] {
out << "a::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(x == *old_x + *old_s);
BOOST_CONTRACT_ASSERT(s.find(*old_x) != std::string::npos);
})
;
out << "a::f::body" << std::endl;
std::string save_s = s;
std::string save = x;
x += save_s;
s = save;
save = y;
y += save_s;
s += save;
save = t<'d'>::z;
t<'d'>::z += save_s;
s += save;
save = t<'e'>::z;
t<'e'>::z += save_s;
s += save;
}
BOOST_CONTRACT_INTROSPECT(f)
};
int main() {
a aa;
std::string s = "!";
aa.f(s);
std::cout << s << std::endl;
std::cout << aa.x << std::endl;
std::cout << aa.y << std::endl;
std::cout << aa.t<'d'>::z << std::endl;
//BOOST_TEST_EQ(aa.val(), 456);
//BOOST_TEST_EQ(i, 123);
return boost::report_errors();
}