[Boost-commit] svn:boost r65393 - sandbox/sync/libs/sync/test

Subject: [Boost-commit] svn:boost r65393 - sandbox/sync/libs/sync/test
From: vicente.botet_at_[hidden]
Date: 2010-09-12 07:12:26

Author: viboes
Date: 2010-09-12 07:12:25 EDT (Sun, 12 Sep 2010)
New Revision: 65393
URL: http://svn.boost.org/trac/boost/changeset/65393

Log:
Boost.Sync: unify Kind and Category
Text files modified: 
   sandbox/sync/libs/sync/test/lockable_concepts_test.cpp |     4 +                                       
   sandbox/sync/libs/sync/test/lockable_traits_test.cpp   |    80 +++++++++++++++++++---------------------
   2 files changed, 41 insertions(+), 43 deletions(-)

Modified: sandbox/sync/libs/sync/test/lockable_concepts_test.cpp
==============================================================================
--- sandbox/sync/libs/sync/test/lockable_concepts_test.cpp	(original)
+++ sandbox/sync/libs/sync/test/lockable_concepts_test.cpp	2010-09-12 07:12:25 EDT (Sun, 12 Sep 2010)
@@ -81,7 +81,7 @@
 BOOST_CONCEPT_ASSERT((TryLockableConcept<boost::shared_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<boost::shared_mutex>));    
 BOOST_CONCEPT_ASSERT((ShareLockableConcept<boost::shared_mutex>));    
-BOOST_CONCEPT_ASSERT((UpgradeLockableConcept<boost::shared_mutex>));   
+BOOST_CONCEPT_ASSERT((UpgradeBasicLockableConcept<boost::shared_mutex>));   
 
 BOOST_CONCEPT_ASSERT((BasicLockableConcept<interprocess_mutex>));    
 BOOST_CONCEPT_ASSERT((TryLockableConcept<interprocess_mutex>));    
@@ -99,9 +99,11 @@
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<interprocess_upgradable_mutex>));    
 BOOST_CONCEPT_ASSERT((ShareLockableConcept<interprocess_upgradable_mutex>));    
 BOOST_CONCEPT_ASSERT((UpgradeLockableConcept<interprocess_upgradable_mutex>));    
+BOOST_CONCEPT_ASSERT((UpgradeTimedLockableConcept<interprocess_upgradable_mutex>));    
 
 BOOST_CONCEPT_ASSERT((TryLockableConcept<named_upgradable_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<named_upgradable_mutex>));    
 BOOST_CONCEPT_ASSERT((ShareLockableConcept<named_upgradable_mutex>));    
 BOOST_CONCEPT_ASSERT((UpgradeLockableConcept<named_upgradable_mutex>));    
+BOOST_CONCEPT_ASSERT((UpgradeTimedLockableConcept<named_upgradable_mutex>));    
 

Modified: sandbox/sync/libs/sync/test/lockable_traits_test.cpp
==============================================================================
--- sandbox/sync/libs/sync/test/lockable_traits_test.cpp	(original)
+++ sandbox/sync/libs/sync/test/lockable_traits_test.cpp	2010-09-12 07:12:25 EDT (Sun, 12 Sep 2010)
@@ -49,92 +49,88 @@
 
 BOOST_STATIC_ASSERT((is_same<best_condition<sync::null_mutex>::type, null_condition>::value));
 BOOST_STATIC_ASSERT((is_same<scope<sync::null_mutex>::type, mono_threaded_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<sync::null_mutex>::type, upgradable_lock_tag>::value));
+BOOST_STATIC_ASSERT((is_same<category<sync::null_mutex>::type, upgradable_timed_lockable_tag>::value));
 BOOST_STATIC_ASSERT((is_same<reentrancy<sync::null_mutex>::type, recursive_tag>::value));
-BOOST_STATIC_ASSERT((is_same<kind<sync::null_mutex>::type, timed_lockable_tag>::value));
-BOOST_STATIC_ASSERT((is_exclusive_lock<sync::null_mutex>::value));
-BOOST_STATIC_ASSERT((is_sharable_lock<sync::null_mutex>::value));
-BOOST_STATIC_ASSERT((is_upgradable_lock<sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((is_exclusive<sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((is_sharable<sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((is_upgradable<sync::null_mutex>::value));
 BOOST_STATIC_ASSERT((is_mono_threaded<sync::null_mutex>::value));
 BOOST_STATIC_ASSERT((!is_multi_threaded<sync::null_mutex>::value));
 BOOST_STATIC_ASSERT((!is_multi_process<sync::null_mutex>::value));
-BOOST_STATIC_ASSERT((is_recursive_lock<sync::null_mutex>::value));
-BOOST_STATIC_ASSERT((is_timed_lockable<sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((is_recursive<sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((!is_owned<sync::null_mutex>::value));
 
 //~ BOOST_STATIC_ASSERT((is_same<best_condition<mutex>::type, boost::condition_variable>::value));
 BOOST_STATIC_ASSERT((is_same<scope<mutex>::type, multi_threaded_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<mutex>::type, exclusive_lock_tag>::value));
-BOOST_STATIC_ASSERT((!is_recursive_lock<mutex>::value));
-BOOST_STATIC_ASSERT((is_same<kind<mutex>::type, try_lockable_tag>::value));
-BOOST_STATIC_ASSERT((is_exclusive_lock<mutex>::value));
-BOOST_STATIC_ASSERT((!is_sharable_lock<mutex>::value));
-BOOST_STATIC_ASSERT((!is_upgradable_lock<mutex>::value));
+BOOST_STATIC_ASSERT((is_same<category<mutex>::type, exclusive_try_lockable_tag>::value));
+BOOST_STATIC_ASSERT((!is_recursive<mutex>::value));
+BOOST_STATIC_ASSERT((is_exclusive<mutex>::value));
+BOOST_STATIC_ASSERT((!is_sharable<mutex>::value));
+BOOST_STATIC_ASSERT((!is_upgradable<mutex>::value));
 BOOST_STATIC_ASSERT((is_mono_threaded<mutex>::value));
 BOOST_STATIC_ASSERT((is_multi_threaded<mutex>::value));
 BOOST_STATIC_ASSERT((!is_multi_process<mutex>::value));
-BOOST_STATIC_ASSERT((!is_recursive_lock<mutex>::value));
-BOOST_STATIC_ASSERT((!is_timed_lockable<mutex>::value));
+BOOST_STATIC_ASSERT((!is_recursive<mutex>::value));
+BOOST_STATIC_ASSERT((is_owned<mutex>::value));
 
 
 BOOST_STATIC_ASSERT((is_same<scope<timed_mutex>::type, multi_threaded_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<timed_mutex>::type, exclusive_lock_tag>::value));
+BOOST_STATIC_ASSERT((is_same<category<timed_mutex>::type, exclusive_timed_lockable_tag>::value));
 BOOST_STATIC_ASSERT((is_same<reentrancy<timed_mutex>::type, non_recursive_tag>::value));
-BOOST_STATIC_ASSERT((is_same<kind<timed_mutex>::type, timed_lockable_tag>::value));
-BOOST_STATIC_ASSERT((is_exclusive_lock<timed_mutex>::value));
-BOOST_STATIC_ASSERT((!is_sharable_lock<timed_mutex>::value));
-BOOST_STATIC_ASSERT((!is_upgradable_lock<timed_mutex>::value));
+BOOST_STATIC_ASSERT((is_exclusive<timed_mutex>::value));
+BOOST_STATIC_ASSERT((!is_sharable<timed_mutex>::value));
+BOOST_STATIC_ASSERT((!is_upgradable<timed_mutex>::value));
 BOOST_STATIC_ASSERT((is_mono_threaded<timed_mutex>::value));
 BOOST_STATIC_ASSERT((is_multi_threaded<timed_mutex>::value));
 BOOST_STATIC_ASSERT((!is_multi_process<timed_mutex>::value));
-BOOST_STATIC_ASSERT((!is_recursive_lock<timed_mutex>::value));
-BOOST_STATIC_ASSERT((is_timed_lockable<timed_mutex>::value));
+BOOST_STATIC_ASSERT((!is_recursive<timed_mutex>::value));
+BOOST_STATIC_ASSERT((is_owned<timed_mutex>::value));
 
 BOOST_STATIC_ASSERT((is_same<scope<recursive_mutex>::type, multi_threaded_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<recursive_mutex>::type, exclusive_lock_tag>::value));
+BOOST_STATIC_ASSERT((is_same<category<recursive_mutex>::type, exclusive_try_lockable_tag>::value));
 BOOST_STATIC_ASSERT((is_same<reentrancy<recursive_mutex>::type, recursive_tag>::value));
-BOOST_STATIC_ASSERT((is_same<kind<recursive_mutex>::type, try_lockable_tag>::value));
-BOOST_STATIC_ASSERT((is_exclusive_lock<recursive_mutex>::value));
-BOOST_STATIC_ASSERT((!is_sharable_lock<recursive_mutex>::value));
-BOOST_STATIC_ASSERT((!is_upgradable_lock<recursive_mutex>::value));
+BOOST_STATIC_ASSERT((is_exclusive<recursive_mutex>::value));
+BOOST_STATIC_ASSERT((!is_sharable<recursive_mutex>::value));
+BOOST_STATIC_ASSERT((!is_upgradable<recursive_mutex>::value));
 BOOST_STATIC_ASSERT((is_mono_threaded<recursive_mutex>::value));
 BOOST_STATIC_ASSERT((is_multi_threaded<recursive_mutex>::value));
 BOOST_STATIC_ASSERT((!is_multi_process<recursive_mutex>::value));
-BOOST_STATIC_ASSERT((is_recursive_lock<recursive_mutex>::value));
-BOOST_STATIC_ASSERT((!is_timed_lockable<recursive_mutex>::value));
+BOOST_STATIC_ASSERT((is_recursive<recursive_mutex>::value));
+BOOST_STATIC_ASSERT((is_owned<recursive_mutex>::value));
 
 BOOST_STATIC_ASSERT((is_same<scope<recursive_timed_mutex>::type, multi_threaded_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<recursive_timed_mutex>::type, exclusive_lock_tag>::value));
+BOOST_STATIC_ASSERT((is_same<category<recursive_timed_mutex>::type, exclusive_timed_lockable_tag>::value));
 
 BOOST_STATIC_ASSERT((is_same<scope<shared_mutex>::type, multi_threaded_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<shared_mutex>::type, upgradable_lock_tag>::value));
-BOOST_STATIC_ASSERT((is_exclusive_lock<shared_mutex>::value));
-BOOST_STATIC_ASSERT((is_sharable_lock<shared_mutex>::value));
-BOOST_STATIC_ASSERT((is_upgradable_lock<shared_mutex>::value));
+BOOST_STATIC_ASSERT((is_same<category<shared_mutex>::type, upgradable_basic_lockable_tag>::value));
+BOOST_STATIC_ASSERT((is_exclusive<shared_mutex>::value));
+BOOST_STATIC_ASSERT((is_sharable<shared_mutex>::value));
+BOOST_STATIC_ASSERT((is_upgradable<shared_mutex>::value));
 BOOST_STATIC_ASSERT((is_mono_threaded<shared_mutex>::value));
 BOOST_STATIC_ASSERT((is_multi_threaded<shared_mutex>::value));
 BOOST_STATIC_ASSERT((!is_multi_process<shared_mutex>::value));
 
 BOOST_STATIC_ASSERT((is_same<scope<interprocess_mutex>::type, multi_process_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<interprocess_mutex>::type, exclusive_lock_tag>::value));
-BOOST_STATIC_ASSERT((is_exclusive_lock<interprocess_mutex>::value));
-BOOST_STATIC_ASSERT((!is_sharable_lock<interprocess_mutex>::value));
-BOOST_STATIC_ASSERT((!is_upgradable_lock<interprocess_mutex>::value));
+BOOST_STATIC_ASSERT((is_same<category<interprocess_mutex>::type, exclusive_timed_lockable_tag>::value));
+BOOST_STATIC_ASSERT((is_exclusive<interprocess_mutex>::value));
+BOOST_STATIC_ASSERT((!is_sharable<interprocess_mutex>::value));
+BOOST_STATIC_ASSERT((!is_upgradable<interprocess_mutex>::value));
 BOOST_STATIC_ASSERT((is_mono_threaded<interprocess_mutex>::value));
 BOOST_STATIC_ASSERT((is_multi_threaded<interprocess_mutex>::value));
 BOOST_STATIC_ASSERT((is_multi_process<interprocess_mutex>::value));
 
 BOOST_STATIC_ASSERT((is_same<scope<interprocess_recursive_mutex>::type, multi_process_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<interprocess_recursive_mutex>::type, exclusive_lock_tag>::value));
+BOOST_STATIC_ASSERT((is_same<category<interprocess_recursive_mutex>::type, exclusive_timed_lockable_tag>::value));
 
 BOOST_STATIC_ASSERT((is_same<scope<named_mutex>::type, multi_process_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<named_mutex>::type, exclusive_lock_tag>::value));
+BOOST_STATIC_ASSERT((is_same<category<named_mutex>::type, exclusive_timed_lockable_tag>::value));
 
 
 BOOST_STATIC_ASSERT((is_same<scope<interprocess_upgradable_mutex>::type, multi_process_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<interprocess_upgradable_mutex>::type, upgradable_lock_tag>::value));
+BOOST_STATIC_ASSERT((is_same<category<interprocess_upgradable_mutex>::type, upgradable_timed_lockable_tag>::value));
 
 BOOST_STATIC_ASSERT((is_same<scope<named_upgradable_mutex>::type, multi_process_tag>::value));
-BOOST_STATIC_ASSERT((is_same<category<named_upgradable_mutex>::type, upgradable_lock_tag>::value));
+BOOST_STATIC_ASSERT((is_same<category<named_upgradable_mutex>::type, upgradable_timed_lockable_tag>::value));