Changeset 44838


Ignore:
Timestamp:
Apr 28, 2008, 9:00:58 AM (11 years ago)
Author:
Anthony Williams
Message:

Added detail::try_lock_wrapper for use as scoped_try_lock typedefs, to fix issue #1873

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/boost/thread/detail/move.hpp

    r43730 r44838  
    1919            {}
    2020
     21            T& operator*() const
     22            {
     23                return t;
     24            }
     25
    2126            T* operator->() const
    2227            {
  • trunk/boost/thread/locks.hpp

    r44370 r44838  
    588588    };
    589589
     590    namespace detail
     591    {
     592        template<typename Mutex>
     593        class try_lock_wrapper:
     594            private unique_lock<Mutex>
     595        {
     596            typedef unique_lock<Mutex> base;
     597        public:
     598            explicit try_lock_wrapper(Mutex& m):
     599                base(m,try_to_lock)
     600            {}
     601
     602            try_lock_wrapper(Mutex& m_,adopt_lock_t):
     603                base(m_,adopt_lock)
     604            {}
     605            try_lock_wrapper(Mutex& m_,defer_lock_t):
     606                base(m_,defer_lock)
     607            {}
     608            try_lock_wrapper(Mutex& m_,try_to_lock_t):
     609                base(m,try_to_lock)
     610            {}
     611            try_lock_wrapper(detail::thread_move_t<try_lock_wrapper<Mutex> > other):
     612                base(detail::thread_move_t<base>(*other))
     613            {}
     614
     615            operator detail::thread_move_t<try_lock_wrapper<Mutex> >()
     616            {
     617                return move();
     618            }
     619
     620            detail::thread_move_t<try_lock_wrapper<Mutex> > move()
     621            {
     622                return detail::thread_move_t<try_lock_wrapper<Mutex> >(*this);
     623            }
     624
     625            try_lock_wrapper& operator=(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
     626            {
     627                try_lock_wrapper temp(other);
     628                swap(temp);
     629                return *this;
     630            }
     631
     632            void swap(try_lock_wrapper& other)
     633            {
     634                base::swap(other);
     635            }
     636            void swap(detail::thread_move_t<try_lock_wrapper<Mutex> > other)
     637            {
     638                base::swap(*other);
     639            }
     640
     641            using base::lock;
     642            using base::try_lock;
     643            using base::unlock;
     644            using base::owns_lock;
     645            using base::operator!;
     646            using base::mutex;
     647            using base::release;
     648       
     649            typedef void (unique_lock::*bool_type)();
     650            operator bool_type() const
     651            {
     652                return owns_lock()?&unique_lock::lock:0;
     653            }
     654        };
     655    }
    590656}
    591657
  • trunk/boost/thread/pthread/mutex.hpp

    r44147 r44838  
    7070
    7171        typedef unique_lock<mutex> scoped_lock;
    72         typedef scoped_lock scoped_try_lock;
     72        typedef detail::try_lock_wrapper<mutex> scoped_try_lock;
    7373    };
    7474
     
    188188
    189189        typedef unique_lock<timed_mutex> scoped_timed_lock;
    190         typedef scoped_timed_lock scoped_try_lock;
     190        typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
    191191        typedef scoped_timed_lock scoped_lock;
    192192    };
  • trunk/boost/thread/pthread/recursive_mutex.hpp

    r40787 r44838  
    7878        }
    7979        typedef unique_lock<recursive_mutex> scoped_lock;
    80         typedef scoped_lock scoped_try_lock;
     80        typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
    8181    };
    8282
     
    240240
    241241        typedef unique_lock<recursive_timed_mutex> scoped_timed_lock;
    242         typedef scoped_timed_lock scoped_try_lock;
     242        typedef detail::try_lock_wrapper<recursive_timed_mutex> scoped_try_lock;
    243243        typedef scoped_timed_lock scoped_lock;
    244244    };
  • trunk/boost/thread/win32/mutex.hpp

    r39784 r44838  
    3333
    3434        typedef unique_lock<mutex> scoped_lock;
    35         typedef scoped_lock scoped_try_lock;
     35        typedef detail::try_lock_wrapper<mutex> scoped_try_lock;
    3636    };
    3737
     
    5454
    5555        typedef unique_lock<timed_mutex> scoped_timed_lock;
    56         typedef scoped_timed_lock scoped_try_lock;
     56        typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
    5757        typedef scoped_timed_lock scoped_lock;
    5858    };
  • trunk/boost/thread/win32/recursive_mutex.hpp

    r39784 r44838  
    3333
    3434        typedef unique_lock<recursive_mutex> scoped_lock;
    35         typedef scoped_lock scoped_try_lock;
     35        typedef detail::try_lock_wrapper<recursive_mutex> scoped_try_lock;
    3636    };
    3737
     
    5353
    5454        typedef unique_lock<recursive_timed_mutex> scoped_timed_lock;
    55         typedef scoped_timed_lock scoped_try_lock;
     55        typedef detail::try_lock_wrapper<recursive_timed_mutex> scoped_try_lock;
    5656        typedef scoped_timed_lock scoped_lock;
    5757    };
  • trunk/libs/smart_ptr/test/Jamfile.v2

    r44636 r44838  
    4646          [ run sp_accept_owner_test.cpp ]
    4747          [ run sp_atomic_test.cpp ]
     48          [ run sp_atomic_mt_test.cpp  : :  : <threading>multi <library>/boost/thread//boost_thread ]
    4849        ;
    4950}
  • trunk/libs/thread/test/test_lock_concept.cpp

    r39891 r44838  
    88#include <boost/mpl/vector.hpp>
    99#include <boost/thread/mutex.hpp>
     10#include <boost/thread/thread.hpp>
    1011#include <boost/thread/recursive_mutex.hpp>
     12#include <boost/thread/condition_variable.hpp>
    1113
    1214template<typename Mutex,typename Lock>
     
    2022        BOOST_CHECK(lock);
    2123        BOOST_CHECK(lock.owns_lock());
     24    }
     25};
     26
     27template<typename Mutex,typename Lock>
     28struct test_initially_unlocked_if_other_thread_has_lock
     29{
     30    Mutex m;
     31    boost::mutex done_mutex;
     32    bool done;
     33    bool locked;
     34    boost::condition_variable done_cond;
     35   
     36    test_initially_unlocked_if_other_thread_has_lock():
     37        done(false),locked(false)
     38    {}
     39
     40    void locking_thread()
     41    {
     42        Lock lock(m);
     43
     44        boost::lock_guard<boost::mutex> lk(done_mutex);
     45        locked=lock.owns_lock();
     46        done=true;
     47        done_cond.notify_one();
     48    }
     49
     50    bool is_done() const
     51    {
     52        return done;
     53    }
     54   
     55
     56    void operator()()
     57    {
     58        Lock lock(m);
     59
     60        typedef test_initially_unlocked_if_other_thread_has_lock<Mutex,Lock> this_type;
     61
     62        boost::thread t(&this_type::locking_thread,this);
     63
     64        try
     65        {
     66            {
     67                boost::mutex::scoped_lock lk(done_mutex);
     68                BOOST_CHECK(done_cond.timed_wait(lk,boost::posix_time::seconds(2),
     69                                                 boost::bind(&this_type::is_done,this)));
     70                BOOST_CHECK(!locked);
     71            }
     72           
     73            lock.unlock();
     74            t.join();
     75        }
     76        catch(...)
     77        {
     78            lock.unlock();
     79            t.join();
     80            throw;
     81        }
    2282    }
    2383};
     
    145205   
    146206    test_initially_locked<Mutex,Lock>()();
     207    test_initially_unlocked_if_other_thread_has_lock<Mutex,Lock>()();
    147208    test_initially_unlocked_with_defer_lock_parameter<Mutex,Lock>()();
    148209    test_initially_locked_with_adopt_lock_parameter<Mutex,Lock>()();
Note: See TracChangeset for help on using the changeset viewer.