Suppose I have a boost::upgrade_lock<boost::shared_mutex>.  When I want to create the boost::upgrade_to_unique_lock<boost::shared_mutex> and upgrade to exclusive locking, this blocks until all the shared lock holders leave.  However, it does not appear that there is a non-blocking version of this, unlike, say, making a boost::unique_lock<boost::shared_mutex> and passing in boost::try_to_lock.

So what should I do in order to create my own "try-upgrade" lock?  I'm trying to use it like so:

boost::upgrade_lock<boost::shared_mutex> upgradeLock(mutex);
...
if (...) {
    // Substitute for boost::upgrade_to_unique_lock<boost::shared_mutex>, but also with aspects of
    // boost::try_to_lock, basically
    my_upgrade_to_unique_lock<boost::shared_mutex> deferredWriteLock(lock);
    
    // Do stuff where it doesn't matter whether I have exclusive or not, while the readers leave
    if (!deferredWriteLock) deferredWriteLock.lock();    // Now we need exclusive
    // We have exclusive, do more stuff
}
// Back to regular upgrade_lock here

upgrade_mutex mut;
// ...
void foo()
{
    shared_lock<upgrade_mutex> sl(mut);
    // mut share locked here
    // ...
    // Try to convert mut from shared to upgrade ownership for 5ms
    // It can succeed if no other thread has upgrade ownership,
    //   or is blocked on exclusive ownership.
    upgrade_lock<upgrade_mutex> ul(std::move(sl), chrono::milliseconds(5));
    if (ul.owns_lock())
    {
        // mut upgrade locked here
        // This thread will still share with other threads having shared ownership here.
        // ...
        // Convert mut from upgrade to exclusive, blocking as necessary
        unique_lock<upgrade_mutex> el(std::move(ul));
        // mut exclusive locked here
        // No other threads have shared, upgrade or exclusive ownership here.
        // ...
    }  // mut.unlock()
    else
    {
        // mut still share locked here
        // ...
    }
}  // if mut is share locked, then mut.unlock_shared()