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

Subject: [Boost-commit] svn:boost r65406 - sandbox/sync/libs/sync/test
From: vicente.botet_at_[hidden]
Date: 2010-09-13 01:25:09

Author: viboes
Date: 2010-09-13 01:25:08 EDT (Mon, 13 Sep 2010)
New Revision: 65406
URL: http://svn.boost.org/trac/boost/changeset/65406

Log:
fix compiler error with gcc3.4
Text files modified: 
   sandbox/sync/libs/sync/test/lockable_concepts_test.cpp |    44 ++++++++++++++++++++--------------------
   sandbox/sync/libs/sync/test/lockable_traits_test.cpp   |    24 ++++++++++----------                    
   2 files changed, 34 insertions(+), 34 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-13 01:25:08 EDT (Mon, 13 Sep 2010)
@@ -47,63 +47,63 @@
 using namespace boost::sync;
 using namespace boost::interprocess;
 
-BOOST_CONCEPT_ASSERT((BasicLockableConcept<sync::null_mutex>));    
-BOOST_CONCEPT_ASSERT((TryLockableConcept<sync::null_mutex>));    
-BOOST_CONCEPT_ASSERT((TimedLockableConcept<sync::null_mutex>));    
-BOOST_CONCEPT_ASSERT((ShareLockableConcept<sync::null_mutex>));    
-BOOST_CONCEPT_ASSERT((UpgradeLockableConcept<sync::null_mutex>));    
+BOOST_CONCEPT_ASSERT((BasicLockableConcept< ::boost::sync::null_mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept< ::boost::sync::null_mutex>));    
+BOOST_CONCEPT_ASSERT((TimedLockableConcept< ::boost::sync::null_mutex>));    
+BOOST_CONCEPT_ASSERT((SharedLockableConcept< ::boost::sync::null_mutex>));    
+BOOST_CONCEPT_ASSERT((UpgradeLockableConcept< ::boost::sync::null_mutex>));    
 
-//~ BOOST_CONCEPT_ASSERT((TryLockableConcept<exclusive_lockable_adapter<null_mutex> >));    
+//~ BOOST_CONCEPT_ASSERT((LockableConcept<exclusive_lockable_adapter<null_mutex> >));    
 //~ BOOST_CONCEPT_ASSERT((TimedLockableConcept<timed_lockable_adapter<null_mutex> >));    
-//~ BOOST_CONCEPT_ASSERT((ShareLockableConcept<shared_lockable_adapter<null_mutex> >));    
+//~ BOOST_CONCEPT_ASSERT((SharedLockableConcept<shared_lockable_adapter<null_mutex> >));    
 //~ BOOST_CONCEPT_ASSERT((UpgradeLockableConcept<upgrade_lockable_adapter<null_mutex> >));    
 
-//~ BOOST_CONCEPT_ASSERT((TryLockableConcept<poly::exclusive_lock_adapter<null_mutex> >));    
+//~ BOOST_CONCEPT_ASSERT((LockableConcept<poly::exclusive_lock_adapter<null_mutex> >));    
 //~ BOOST_CONCEPT_ASSERT((TimedLockableConcept<poly::timed_lock_adapter<null_mutex> >));    
-//~ BOOST_CONCEPT_ASSERT((ShareLockableConcept<poly::sharable_lock_adapter<null_mutex> >));    
+//~ BOOST_CONCEPT_ASSERT((SharedLockableConcept<poly::sharable_lock_adapter<null_mutex> >));    
 //~ BOOST_CONCEPT_ASSERT((UpgradeLockableConcept<poly::upgradable_lock_adapter<null_mutex> >));    
 
 BOOST_CONCEPT_ASSERT((BasicLockableConcept<boost::mutex>));    
-BOOST_CONCEPT_ASSERT((TryLockableConcept<boost::mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept<boost::mutex>));    
 
 BOOST_CONCEPT_ASSERT((BasicLockableConcept<boost::timed_mutex>));    
-BOOST_CONCEPT_ASSERT((TryLockableConcept<boost::timed_mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept<boost::timed_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<boost::timed_mutex>));    
 
 BOOST_CONCEPT_ASSERT((BasicLockableConcept<boost::recursive_mutex>));    
-BOOST_CONCEPT_ASSERT((TryLockableConcept<boost::recursive_mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept<boost::recursive_mutex>));    
 
 BOOST_CONCEPT_ASSERT((BasicLockableConcept<boost::recursive_timed_mutex>));    
-BOOST_CONCEPT_ASSERT((TryLockableConcept<boost::recursive_timed_mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept<boost::recursive_timed_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<boost::recursive_timed_mutex>));    
 
 BOOST_CONCEPT_ASSERT((BasicLockableConcept<boost::shared_mutex>));    
-BOOST_CONCEPT_ASSERT((TryLockableConcept<boost::shared_mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept<boost::shared_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<boost::shared_mutex>));    
-BOOST_CONCEPT_ASSERT((ShareLockableConcept<boost::shared_mutex>));    
+BOOST_CONCEPT_ASSERT((SharedLockableConcept<boost::shared_mutex>));    
 BOOST_CONCEPT_ASSERT((UpgradeBasicLockableConcept<boost::shared_mutex>));   
 
 BOOST_CONCEPT_ASSERT((BasicLockableConcept<interprocess_mutex>));    
-BOOST_CONCEPT_ASSERT((TryLockableConcept<interprocess_mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept<interprocess_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<interprocess_mutex>));    
 
 BOOST_CONCEPT_ASSERT((BasicLockableConcept<interprocess_recursive_mutex>));    
-BOOST_CONCEPT_ASSERT((TryLockableConcept<interprocess_recursive_mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept<interprocess_recursive_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<interprocess_recursive_mutex>));    
 
 BOOST_CONCEPT_ASSERT((BasicLockableConcept<named_mutex>));    
-BOOST_CONCEPT_ASSERT((TryLockableConcept<named_mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept<named_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<named_mutex>));    
 
-BOOST_CONCEPT_ASSERT((TryLockableConcept<interprocess_upgradable_mutex>));    
+BOOST_CONCEPT_ASSERT((LockableConcept<interprocess_upgradable_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<interprocess_upgradable_mutex>));    
-BOOST_CONCEPT_ASSERT((ShareLockableConcept<interprocess_upgradable_mutex>));    
+BOOST_CONCEPT_ASSERT((SharedLockableConcept<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((LockableConcept<named_upgradable_mutex>));    
 BOOST_CONCEPT_ASSERT((TimedLockableConcept<named_upgradable_mutex>));    
-BOOST_CONCEPT_ASSERT((ShareLockableConcept<named_upgradable_mutex>));    
+BOOST_CONCEPT_ASSERT((SharedLockableConcept<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-13 01:25:08 EDT (Mon, 13 Sep 2010)
@@ -47,18 +47,18 @@
 using namespace boost::interprocess;
 
 
-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_timed_lockable_tag>::value));
-BOOST_STATIC_ASSERT((is_same<reentrancy<sync::null_mutex>::type, recursive_tag>::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<sync::null_mutex>::value));
-BOOST_STATIC_ASSERT((!is_owned<sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((is_same<best_condition< ::boost::sync::null_mutex>::type, null_condition>::value));
+BOOST_STATIC_ASSERT((is_same<scope< ::boost::sync::null_mutex>::type, mono_threaded_tag>::value));
+BOOST_STATIC_ASSERT((is_same<category< ::boost::sync::null_mutex>::type, upgradable_timed_lockable_tag>::value));
+BOOST_STATIC_ASSERT((is_same<reentrancy< ::boost::sync::null_mutex>::type, recursive_tag>::value));
+BOOST_STATIC_ASSERT((is_exclusive< ::boost::sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((is_sharable< ::boost::sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((is_upgradable< ::boost::sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((is_mono_threaded< ::boost::sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((!is_multi_threaded< ::boost::sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((!is_multi_process< ::boost::sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((is_recursive< ::boost::sync::null_mutex>::value));
+BOOST_STATIC_ASSERT((!is_owned< ::boost::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));