checked classes for copyable/non-copyable

include/boost/contract/aux_/auto_ptr.hpp

@@ -13,7 +13,7 @@ namespace boost { namespace contract { namespace aux {
 // Using this instead of std::auto_ptr because std::auto_ptr will be removed in
 // C++17 (this library always uses release() to avoid ownership issues).
 template<typename T>
-class auto_ptr {
+class auto_ptr { // Copyable (using default copy operations).
 public:
     explicit auto_ptr(T* ptr = 0) : ptr_(ptr) {}
 

include/boost/contract/aux_/check_guard.hpp

@@ -2,11 +2,18 @@
 #ifndef BOOST_CONTRACT_AUX_CHECK_GUARD_HPP_
 #define BOOST_CONTRACT_AUX_CHECK_GUARD_HPP_
 
+/** @cond */
+#include <boost/noncopyable.hpp>
+/** @endcond */
+
 namespace boost { namespace contract { namespace aux {
 
 // TODO: Consider what to do with multi-threads... shall I use multi-reads/one-write locks via boost::shared_mutex? should each thread have its own contract checking bool resource? If global locks must be introduced, provide a NO_TREAD_SAFE configuration macro to disable them.
 
-struct check_guard {
+class check_guard :
+    private boost::noncopyable // Non-copyable resource (might use mutex, etc.).
+{
+public:
     explicit check_guard() { checking_ = true; }
     ~check_guard() { checking_ = false; }
     

include/boost/contract/aux_/condition/check_base.hpp

@@ -6,6 +6,7 @@
 #include <boost/contract/core/exception.hpp>
 /** @cond */
 #include <boost/function.hpp>
+#include <boost/noncopyable.hpp>
 #include <boost/config.hpp>
 #ifndef BOOST_CONTRACT_CONFIG_ON_MISSING_GUARD
 #   include <cassert>
@@ -16,7 +17,9 @@
 
 namespace boost { namespace contract { namespace aux {
 
-class check_base { // Base to hold all contract objects for RAII.
+class check_base : // Base to hold all contract objects for RAII.
+    private boost::noncopyable // Avoid copying possible user's ftor captures.
+{
 public:
     explicit check_base(boost::contract::from from) :
         BOOST_CONTRACT_ERROR_missing_guard_declaration(false),

include/boost/contract/aux_/condition/check_pre_post.hpp

@@ -16,10 +16,8 @@
 
 namespace boost { namespace contract { namespace aux {
 
-// TODO: Does this need to be copied? Copying function<> could copy captures (if function is a lambda) and it could be expensive... check all classes that MUST be copyable, make sure their copies are efficient, make all other classes noncopyable. Same consideration for all other classes, make noncopyable all classes that do not have to be necessarily copyable.
-
 template<typename R>
-class check_pre_post : public check_base {
+class check_pre_post : public check_base { // Non-copyable base.
     typedef typename boost::mpl::if_<is_optional<R>,
         boost::optional<typename boost::remove_reference<
                 typename optional_value_type<R>::type>::type const&> const&
@@ -51,7 +49,7 @@ private:
 };
 
 template<>
-class check_pre_post<none> : public check_base {
+class check_pre_post<none> : public check_base { // Non-copyable base.
 public:
     explicit check_pre_post(boost::contract::from from) : check_base(from) {}
 

include/boost/contract/aux_/condition/check_pre_post_inv.hpp

@@ -24,7 +24,7 @@
 namespace boost { namespace contract { namespace aux {
 
 template<typename R, class C>
-class check_pre_post_inv : public check_pre_post<R> { // Copyable (as *).
+class check_pre_post_inv : public check_pre_post<R> { // Non-copyable base.
 public:
 #ifndef BOOST_CONTRACT_CONFIG_PERMISSIVE
     BOOST_STATIC_ASSERT_MSG(

include/boost/contract/aux_/condition/check_subcontracted_pre_post_inv.hpp

@@ -50,8 +50,8 @@ namespace check_subcontracted_pre_post_inv_ {
 
 // O, R, F, and A-i can be none types (but C cannot).
 template<class O, typename R, typename F, class C, typename A0, typename A1>
-class check_subcontracted_pre_post_inv : // Copyable (as * and &).
-        public check_pre_post_inv<R, C> {
+class check_subcontracted_pre_post_inv :
+        public check_pre_post_inv<R, C> { // Non-copyable base.
     template<class Class, typename Result = boost::mpl::vector<> >
     class overridden_bases_of {
         struct search_bases {

include/boost/contract/aux_/debug.hpp

@@ -2,9 +2,7 @@
 #ifndef BOOST_CONTRACT_AUX_DEBUG_HPP_
 #define BOOST_CONTRACT_AUX_DEBUG_HPP_
 
-/** @cond */
 #include <boost/contract/aux_/config.hpp>
-/** @endcond */
 
 // Usually, never #defined (and debug assertions always in the code).
 #ifdef BOOST_CONTRACT_AUX_CONFIG_NDEBUG

include/boost/contract/aux_/operation/constructor.hpp

@@ -15,7 +15,8 @@ namespace boost { namespace contract { namespace aux {
 
 // Ctor subcontracting impl via C++ obj construction mechanism.
 template<class C>
-class constructor : public check_pre_post_inv</* R = */ none, C> {
+class constructor :
+        public check_pre_post_inv</* R = */ none, C> { // Non-copyable base.
 public:
     explicit constructor(C* obj) :
         check_pre_post_inv</* R = */ none, C>(boost::contract::from_constructor,

include/boost/contract/aux_/operation/destructor.hpp

@@ -15,7 +15,8 @@ namespace boost { namespace contract { namespace aux {
 
 // Dtor subcontracting impl via C++ obj destruction mechanism.
 template<class C>
-class destructor : public check_pre_post_inv</* R = */ none, C> {
+class destructor :
+        public check_pre_post_inv</* R = */ none, C> { // Non-copyable base.
 public:
     explicit destructor(C* obj) :
         check_pre_post_inv</* R = */ none, C>(

include/boost/contract/aux_/operation/function.hpp

@@ -13,7 +13,8 @@
 namespace boost { namespace contract { namespace aux {
 
 // Used for free function, private and protected member functions.
-class function : public check_pre_post</* R = */ none> {
+class function :
+        public check_pre_post</* R = */ none> { // Non-copyable base.
 public:
     explicit function() :
         check_pre_post</* R = */ none>(boost::contract::from_function)

include/boost/contract/aux_/operation/public_function.hpp

@@ -15,7 +15,9 @@ namespace boost { namespace contract { namespace aux {
 
 template<class O, typename R, typename F, class C, typename A0, typename A1>
 class public_function :
-        public check_subcontracted_pre_post_inv<O, R, F, C, A0, A1> {
+    // Non-copyable base.
+    public check_subcontracted_pre_post_inv<O, R, F, C, A0, A1>
+{
 public:
     explicit public_function(boost::contract::virtual_* v, C* obj, R& r,
             A0& a0, A1& a1) :

include/boost/contract/aux_/operation/public_static_function.hpp

@@ -16,7 +16,8 @@ namespace boost { namespace contract { namespace aux {
 
 // No subcontracting because static so no obj and no substitution principle.
 template<class C>
-class public_static_function : public check_pre_post_inv</* R = */ none, C> {
+class public_static_function :
+        public check_pre_post_inv</* R = */ none, C> { // Non-copyable base.
 public:
     explicit public_static_function() :
         check_pre_post_inv</* R = */ none, C>(boost::contract::from_function,

include/boost/contract/aux_/operator_safe_bool.hpp

@@ -8,12 +8,6 @@
 
 // This code is inspired by "boost/shared_ptr/detail/operator_bool.hpp".
     
-/* PRIVATE */
-
-// operator! is redundant, but some compilers need it.
-#define BOOST_CONTRACT_OPERATOR_SAFE_BOOL_NOT_(bool_expr) \
-    bool operator!() const BOOST_NOEXCEPT { return !(bool_expr); }
-
 /* PUBLIC */
 
 #if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) && \
@@ -73,5 +67,11 @@
 
 #endif
 
+/* PRIVATE */
+
+// operator! is redundant, but some compilers need it.
+#define BOOST_CONTRACT_OPERATOR_SAFE_BOOL_NOT_(bool_expr) \
+    bool operator!() const BOOST_NOEXCEPT { return !(bool_expr); }
+
 #endif // #include guard
 

include/boost/contract/call_if.hpp

@@ -2,11 +2,15 @@
 #ifndef BOOST_CONTRACT_CALL_IF_HPP_
 #define BOOST_CONTRACT_CALL_IF_HPP_
 
+// TODO: Check all #includes for all files... and make sure that #include not of this library are within @cond ... @endcond.
+
 #include <boost/contract/aux_/none.hpp>
+/** @cond */
 #include <boost/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/utility/result_of.hpp>
 #include <boost/config.hpp>
+/** @endcond */
 
 /* PRIVATE */
 
@@ -24,7 +28,7 @@
 namespace boost { namespace contract {
 
 template<bool Cond, typename Then, typename R = boost::contract::aux::none>
-struct call_if_statement {}; // Empty so cannot be used.
+struct call_if_statement {}; // Empty so cannot be used (but copyable).
 
 // Dispatch true condition (then) between non-void and void calls.
 // IMPORTANT: result_of<Then()> can be evaluated only when condition is already
@@ -32,7 +36,7 @@ struct call_if_statement {}; // Empty so cannot be used.
 // this extra level of dispatching is necessary to avoid compiler errors.
 template<typename Then>
 struct call_if_statement<true, Then, boost::contract::aux::none> :
-    call_if_statement<true, Then,
+    call_if_statement<true, Then, // Copyable (as its base).
             BOOST_CONTRACT_CALL_IF_ENABLE_IF_UNARY_RESULT_OF_(Then)>
 {
     explicit call_if_statement(Then f) : call_if_statement<true, Then,
@@ -41,7 +45,7 @@ struct call_if_statement<true, Then, boost::contract::aux::none> :
 
 // True condition (then) for non-void call.
 template<typename Then, typename R>
-struct call_if_statement<true, Then, R> { // Copyable as *.
+struct call_if_statement<true, Then, R> { // Copyable (as *).
     explicit call_if_statement(Then f) : r_(boost::make_shared<R>(f())) {}
 
     operator R() const { return *r_; }
@@ -65,7 +69,7 @@ private:
 
 // True condition (then) for void call.
 template<typename Then>
-struct call_if_statement<true, Then, void> {
+struct call_if_statement<true, Then, void> { // Copyable (no data).
     explicit call_if_statement(Then f) { f(); }
     
     // Cannot provide `operator R()` here, because R is void.
@@ -85,7 +89,7 @@ struct call_if_statement<true, Then, void> {
 };
 
 // False condition (else) for both non-void and void calls.
-template<typename Then>
+template<typename Then> // Copyable (no data).
 struct call_if_statement<false, Then, boost::contract::aux::none> {
     explicit call_if_statement(Then const&) {}
 

include/boost/contract/constructor.hpp

@@ -16,9 +16,11 @@ set_old_postcondition<> constructor(C* obj) {
             new boost::contract::aux::constructor<C>(obj));
 }
 
+// TODO: Decl all classes (but TMP) using class and not struct (for easier/consistent fwd decl...).
+
 // Uses C tparam to avoid multiple inheritance from same type.
 template<class C>
-struct constructor_precondition {
+struct constructor_precondition { // Copyable (no data).
     constructor_precondition() {} // For user ctor overloads with no pre.
 
     template<typename F>
@@ -26,6 +28,8 @@ struct constructor_precondition {
         try { f(); }
         catch(...) { precondition_failed(from_constructor); }
     }
+
+    // Default copy operations (so user's derived classes can also be copyable).
 };
 
 } } // namespace

include/boost/contract/core/access.hpp

@@ -37,7 +37,7 @@ namespace boost { namespace contract {
 // reported but invariants and subcontracting checking will be silently skipped
 // at run-time. Therefore programmers must make sure to either declare contract
 // members public or to make this class a friend.
-class access {
+class access { // Copyable (as shell with no data member).
     BOOST_CONTRACT_AUX_INTROSPECTION_HAS_TYPE(has_base_types,
             BOOST_CONTRACT_CONFIG_BASE_TYPES)
 

include/boost/contract/core/exception.hpp

@@ -18,11 +18,11 @@ namespace boost { namespace contract {
 
 // Placeholder base class to group all this lib exceptions.
 // IMPORTANT: Must not inherit from std::exception as derived exceptions will.
-struct exception {};
+class exception {};
 
 // Rationale: boost::bad_any_cast exception does not print from/to type names,
 // so throw custom exception.
-class bad_virtual_result_cast :
+class bad_virtual_result_cast : // Copyable (as string, etc.).
         public std::bad_cast, public boost::contract::exception {
 public:
     explicit bad_virtual_result_cast(char const* from_type_name,
@@ -42,7 +42,7 @@ private:
     std::string what_;
 };
 
-class assertion_failure :
+class assertion_failure : // Copyable (as string, etc.).
         public std::exception, public boost::contract::exception {
 public:
     explicit assertion_failure(char const* const file = "",
@@ -88,6 +88,8 @@ enum from {
     from_function
 };
 
+// TODO: Even if it might be confused with assertion_failure (which is an exception and not a function), all these function names are more readable as ..._failure instead of ..._failed (so they should be renamed that way).
+
 // Use Boost.Function to handle also lambdas, binds, etc,
 typedef boost::function<void (from)> assertion_failed_handler;
 

include/boost/contract/core/set_nothing.hpp

@@ -26,7 +26,7 @@ namespace boost {
     
 namespace boost { namespace contract {
 
-class set_nothing { // Copyable as * (OK also for RAII).
+class set_nothing { // Copyable (as *).
 public:
     ~set_nothing() BOOST_NOEXCEPT_IF(false) {}
     
@@ -34,10 +34,13 @@ public:
 
 private:
     typedef boost::contract::aux::check_base check_type;
+    
     explicit set_nothing(check_type* check) : check_(check) {}
+    
     boost::contract::aux::auto_ptr<check_type> check_;
 
     // Friendship used to limit library's public API.
+
     friend class guard;
 
     template<typename>

include/boost/contract/core/set_old_postcondition.hpp

@@ -24,7 +24,7 @@ namespace boost {
 namespace boost { namespace contract {
     
 template<typename R = void>
-class set_old_postcondition { // Copyable as * (OK also for RAII).
+class set_old_postcondition { // Copyable (as *).
 public:
     ~set_old_postcondition() BOOST_NOEXCEPT_IF(false) {}
     
@@ -45,10 +45,13 @@ public:
 private:
     typedef boost::contract::aux::check_pre_post<
             typename boost::contract::aux::none_if_void<R>::type> check_type;
+
     explicit set_old_postcondition(check_type* check) : check_(check) {}
+    
     boost::contract::aux::auto_ptr<check_type> check_;
 
     // Friendship used to limit library's public API.
+
     friend class guard;
     friend class set_precondition_old_postcondition<R>;
 

include/boost/contract/core/set_postcondition_only.hpp

@@ -26,7 +26,7 @@ namespace boost {
 namespace boost { namespace contract {
     
 template<typename R = void>
-class set_postcondition_only { // Copyable as * (OK also for RAII).
+class set_postcondition_only { // Copyable (as *).
 public:
     ~set_postcondition_only() BOOST_NOEXCEPT_IF(false) {}
 
@@ -40,10 +40,13 @@ public:
 private:
     typedef boost::contract::aux::check_pre_post<
             typename boost::contract::aux::none_if_void<R>::type> check_type;
+
     explicit set_postcondition_only(check_type* check) : check_(check) {}
+
     boost::contract::aux::auto_ptr<check_type> check_;
 
     // Friendship used to limit library's public API.
+
     friend class guard;
     friend class set_precondition_old_postcondition<R>;
     friend class set_old_postcondition<R>;

include/boost/contract/core/set_precondition_old_postcondition.hpp

@@ -24,7 +24,7 @@ namespace boost {
 namespace boost { namespace contract {
     
 template<typename R = void>
-class set_precondition_old_postcondition { // Copy as * (OK for RAII).
+class set_precondition_old_postcondition { // Copyable (as *).
 public:
     ~set_precondition_old_postcondition() BOOST_NOEXCEPT_IF(false) {}
     
@@ -52,11 +52,14 @@ public:
 private:
     typedef boost::contract::aux::check_pre_post<
             typename boost::contract::aux::none_if_void<R>::type> check_type;
+    
     explicit set_precondition_old_postcondition(check_type* check) :
             check_(check) {}
+
     boost::contract::aux::auto_ptr<check_type> check_;
 
     // Friendship used to limit library's public API.
+
     friend class guard;
 
     friend set_precondition_old_postcondition<> function();

include/boost/contract/core/virtual.hpp

@@ -22,7 +22,8 @@ namespace boost {
 namespace boost { namespace contract {
 
 class virtual_ :
-        private boost::noncopyable { // To void queue, stack, etc, copies.
+    private boost::noncopyable // Avoid copying queue, stack, etc.
+{
     // No public API (so users cannot use it directly).
 private:
     enum action_enum {

include/boost/contract/guard.hpp

@@ -12,12 +12,12 @@
 #include <boost/contract/aux_/auto_ptr.hpp>
 #include <boost/contract/aux_/debug.hpp>
 /** @cond */
-#include <boost/noncopyable.hpp>
 #include <boost/config.hpp>
 /** @endcond */
 
 /* PRIVATE */
 
+// Following implicit to allow syntax `guard c = ...`.
 #define BOOST_CONTRACT_GUARD_CTOR_(contract_type) \
     /* implicit */ guard(contract_type const& contract) : \
             check_(const_cast<contract_type&>(contract).check_.release()) { \
@@ -29,10 +29,13 @@
 
 namespace boost { namespace contract {
 
-class guard { // Copyable as * (OK also for RAII).
+class guard { // Non-copyable (but copy ctor ~= move via ptr release).
 public:
-    // Following all implicit to allow syntax `guard c = ...`.
+    // Following copy and implicit type conversion ctors to allow `guard = ...`.
     
+    guard(guard const& other) : 
+            check_(const_cast<guard&>(other).check_.release()) {}
+
     template<typename R>
     BOOST_CONTRACT_GUARD_CTOR_(set_precondition_old_postcondition<R>)
     
@@ -44,9 +47,11 @@ public:
     
     BOOST_CONTRACT_GUARD_CTOR_(set_nothing)
 
-    ~guard() BOOST_NOEXCEPT_IF(false) {}
+    ~guard() BOOST_NOEXCEPT_IF(false) {} // Allow auto_ptr dtor to throw.
 
 private:
+    guard& operator=(guard const&); // This type is not meant to be copied.
+
     boost::contract::aux::auto_ptr<boost::contract::aux::check_base> check_;
 };
 

include/boost/contract/old.hpp

@@ -76,6 +76,7 @@ namespace boost {
     namespace contract {
         class unconvertible_old;
     }
+
     template<>
     struct is_copy_constructible<contract::unconvertible_old> : true_type {};
 }
@@ -103,24 +104,6 @@ private:
     friend class convertible_old;
 };
 
-bool copy_old() {
-#if BOOST_CONTRACT_CONFIG_NO_POSTCONDITIONS
-    return false; // Post checking disabled, so never copy old values.
-#else
-    return !boost::contract::aux::check_guard::checking();
-#endif
-}
-
-bool copy_old(virtual_* v) {
-#if BOOST_CONTRACT_CONFIG_NO_POSTCONDITIONS
-    return false; // Post checking disabled, so never copy old values.
-#else
-    if(!v) return !boost::contract::aux::check_guard::checking();
-    return v->action_ == boost::contract::virtual_::push_old_init ||
-            v->action_ == boost::contract::virtual_::push_old_copy;
-#endif
-}
-
 class unconvertible_old { // Copyable (as *). 
 public:
     // Following implicitly called by ternary operator `... ? ... : null_old()`.
@@ -216,6 +199,24 @@ convertible_old make_old(virtual_* v, unconvertible_old const& old) {
     return convertible_old(v, old);
 }
 
+bool copy_old() {
+#if BOOST_CONTRACT_CONFIG_NO_POSTCONDITIONS
+    return false; // Post checking disabled, so never copy old values.
+#else
+    return !boost::contract::aux::check_guard::checking();
+#endif
+}
+
+bool copy_old(virtual_* v) {
+#if BOOST_CONTRACT_CONFIG_NO_POSTCONDITIONS
+    return false; // Post checking disabled, so never copy old values.
+#else
+    if(!v) return !boost::contract::aux::check_guard::checking();
+    return v->action_ == boost::contract::virtual_::push_old_init ||
+            v->action_ == boost::contract::virtual_::push_old_copy;
+#endif
+}
+
 } } // namespace
 
 #endif // #include guard