SkullCyberArmy Bypass Shell - chauffeursltd.com

Uname : Linux premium36.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Soft : LiteSpeed
Ip : 198.54.115.237
Port : 443

poly_shared_lockable.hpp

//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Vicente J. Botet Escriba 2008-2009,2012. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/thread for documentation.
//
//////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_THREAD_POLY_SHARED_LOCKABLE_HPP
#define BOOST_THREAD_POLY_SHARED_LOCKABLE_HPP

#include <boost/thread/poly_lockable.hpp>
#include <boost/chrono/chrono.hpp>

namespace boost
{

//[shared_poly_lockable
  class shared_poly_lockable: public timed_poly_lockable
  {
  public:
    virtual ~shared_poly_lockable() = 0;

virtual void lock_shared() = 0;
    virtual bool try_lock_shared() = 0;
    virtual void unlock_shared() = 0;

virtual bool try_lock_shared_until(chrono::system_clock::time_point const & abs_time)=0;
    virtual bool try_lock_shared_until(chrono::steady_clock::time_point const & abs_time)=0;
    template <typename Clock, typename Duration>
    bool try_lock_shared_until(chrono::time_point<Clock, Duration> const & abs_time)
    {
      return try_lock_shared_until(chrono::time_point_cast<Clock::time_point>(abs_time));
    }

virtual bool try_lock_shared_for(chrono::nanoseconds const & relative_time)=0;
    template <typename Rep, typename Period>
    bool try_lock_shared_for(chrono::duration<Rep, Period> const & rel_time)
    {
      return try_lock_shared_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
    }

};
  //]

// A proper name for shared_poly_lockable, consistent with naming scheme of other polymorphic wrappers
  typedef shared_poly_lockable poly_shared_lockable;

//[upgrade_poly_lockable
  class upgrade_poly_lockable: public shared_poly_lockable
  {
  public:
    virtual ~upgrade_poly_lockable() = 0;

virtual void lock_upgrade() = 0;
    virtual bool try_lock_upgrade() = 0;
    virtual void unlock_upgrade() = 0;

virtual bool try_lock_upgrade_until(chrono::system_clock::time_point const & abs_time)=0;
    virtual bool try_lock_upgrade_until(chrono::steady_clock::time_point const & abs_time)=0;
    template <typename Clock, typename Duration>
    bool try_lock_upgrade_until(chrono::time_point<Clock, Duration> const & abs_time)
    {
      return try_lock_upgrade_until(chrono::time_point_cast<Clock::time_point>(abs_time));
    }

virtual bool try_lock_upgrade_for(chrono::nanoseconds const & relative_time)=0;
    template <typename Rep, typename Period>
    bool try_lock_upgrade_for(chrono::duration<Rep, Period> const & rel_time)
    {
      return try_lock_upgrade_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
    }

virtual bool try_unlock_shared_and_lock() = 0;

virtual bool try_unlock_shared_and_lock_until(chrono::system_clock::time_point const & abs_time)=0;
    virtual bool try_unlock_shared_and_lock_until(chrono::steady_clock::time_point const & abs_time)=0;
    template <typename Clock, typename Duration>
    bool try_unlock_shared_and_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
    {
      return try_unlock_shared_and_lock_until(chrono::time_point_cast<Clock::time_point>(abs_time));
    }

virtual bool try_unlock_shared_and_lock_for(chrono::nanoseconds const & relative_time)=0;
    template <typename Rep, typename Period>
    bool try_unlock_shared_and_lock_for(chrono::duration<Rep, Period> const & rel_time)
    {
      return try_unlock_shared_and_lock_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
    }

virtual void unlock_and_lock_shared() = 0;
    virtual bool try_unlock_shared_and_lock_upgrade() = 0;

virtual bool try_unlock_shared_and_lock_upgrade_until(chrono::system_clock::time_point const & abs_time)=0;
    virtual bool try_unlock_shared_and_lock_upgrade_until(chrono::steady_clock::time_point const & abs_time)=0;
    template <typename Clock, typename Duration>
    bool try_unlock_shared_and_lock_upgrade_until(chrono::time_point<Clock, Duration> const & abs_time)
    {
      return try_unlock_shared_and_lock_upgrade_until(chrono::time_point_cast<Clock::time_point>(abs_time));
    }

virtual bool try_unlock_shared_and_lock_upgrade_for(chrono::nanoseconds const & relative_time)=0;
    template <typename Rep, typename Period>
    bool try_unlock_shared_and_lock_upgrade_for(chrono::duration<Rep, Period> const & rel_time)
    {
      return try_unlock_shared_and_lock_upgrade_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
    }

virtual void unlock_and_lock_upgrade() = 0;
    virtual void unlock_upgrade_and_lock() = 0;
    virtual bool try_unlock_upgrade_and_lock() = 0;

virtual bool try_unlock_upgrade_and_lock_until(chrono::system_clock::time_point const & abs_time)=0;
    virtual bool try_unlock_upgrade_and_lock_until(chrono::steady_clock::time_point const & abs_time)=0;
    template <typename Clock, typename Duration>
    bool try_unlock_upgrade_and_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
    {
      return try_unlock_upgrade_and_lock_until(chrono::time_point_cast<Clock::time_point>(abs_time));
    }

virtual bool try_unlock_upgrade_and_lock_for(chrono::nanoseconds const & relative_time)=0;
    template <typename Rep, typename Period>
    bool try_unlock_upgrade_and_lock_for(chrono::duration<Rep, Period> const & rel_time)
    {
      return try_unlock_upgrade_and_lock_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
    }

virtual void unlock_upgrade_and_lock_shared() = 0;

};
  //]

// A proper name for upgrade_poly_lockable, consistent with naming scheme of other polymorphic wrappers
  typedef upgrade_poly_lockable poly_upgrade_lockable;
}
#endif

Name	Type	Size	Permission	Last Modified	Actions
.	dir	-	0755	2025-12-17 06:00:31
..	dir	-	0755	2025-12-17 06:00:31
concurrent_queues	dir	-	0755	2025-12-17 06:00:31
csbl	dir	-	0755	2025-12-17 06:00:31
detail	dir	-	0755	2025-12-17 06:00:31
executors	dir	-	0755	2025-12-17 06:00:31
experimental	dir	-	0755	2025-12-17 06:00:31
futures	dir	-	0755	2025-12-17 06:00:31
pthread	dir	-	0755	2025-12-17 06:00:31
v2	dir	-	0755	2025-12-17 06:00:31
barrier.hpp	text/x-c++	7.25 KB	0644	2025-09-16 04:56:08
caller_context.hpp	text/x-c++	1.49 KB	0644	2025-09-16 04:56:08
completion_latch.hpp	text/x-c++	6.42 KB	0644	2025-09-16 04:56:08
condition.hpp	text/x-c++	490 B	0644	2025-09-16 04:56:08
condition_variable.hpp	text/x-c	634 B	0644	2025-09-16 04:56:08
cv_status.hpp	text/x-c++	531 B	0644	2025-09-16 04:56:08
exceptional_ptr.hpp	text/x-c++	1.07 KB	0644	2025-09-16 04:56:08
exceptions.hpp	text/x-c++	6.21 KB	0644	2025-09-16 04:56:08
executor.hpp	text/x-c	476 B	0644	2025-09-16 04:56:08
externally_locked.hpp	text/x-c++	10.62 KB	0644	2025-09-16 04:56:08
externally_locked_stream.hpp	text/x-c++	4.67 KB	0644	2025-09-16 04:56:08
future.hpp	text/x-c++	198.98 KB	0644	2025-09-16 04:56:08
interruption.hpp	text/x-c++	596 B	0644	2025-09-16 04:56:08
is_locked_by_this_thread.hpp	text/x-c++	1.04 KB	0644	2025-09-16 04:56:08
latch.hpp	text/x-c++	4.85 KB	0644	2025-09-16 04:56:08
lock_algorithms.hpp	text/x-c++	12.89 KB	0644	2025-09-16 04:56:08
lock_concepts.hpp	text/x-c++	4.68 KB	0644	2025-09-16 04:56:08
lock_factories.hpp	text/x-c++	2.26 KB	0644	2025-09-16 04:56:08
lock_guard.hpp	text/x-c++	2.24 KB	0644	2025-09-16 04:56:08
lock_options.hpp	text/x-c++	701 B	0644	2025-09-16 04:56:08
lock_traits.hpp	text/x-c++	1.21 KB	0644	2025-09-16 04:56:08
lock_types.hpp	text/x-c++	33.61 KB	0644	2025-09-16 04:56:08
lockable_adapter.hpp	text/x-c++	5.9 KB	0644	2025-09-16 04:56:08
lockable_concepts.hpp	text/x-c++	4.02 KB	0644	2025-09-16 04:56:08
lockable_traits.hpp	text/x-c++	7.67 KB	0644	2025-09-16 04:56:08
locks.hpp	text/x-c	572 B	0644	2025-09-16 04:56:08
mutex.hpp	text/x-c++	1.14 KB	0644	2025-09-16 04:56:08
null_mutex.hpp	text/x-c++	6.2 KB	0644	2025-09-16 04:56:08
once.hpp	text/x-c++	1.3 KB	0644	2025-09-16 04:56:08
ostream_buffer.hpp	text/x-c++	925 B	0644	2025-09-16 04:56:08
poly_lockable.hpp	text/x-c++	2.05 KB	0644	2025-09-16 04:56:08
poly_lockable_adapter.hpp	text/x-c++	2.07 KB	0644	2025-09-16 04:56:08
poly_shared_lockable.hpp	text/x-c++	5.67 KB	0644	2025-09-16 04:56:08
poly_shared_lockable_adapter.hpp	text/x-c++	4.68 KB	0644	2025-09-16 04:56:08
recursive_mutex.hpp	text/x-c++	1.5 KB	0644	2025-09-16 04:56:08
reverse_lock.hpp	text/x-c++	1.29 KB	0644	2025-09-16 04:56:08
scoped_thread.hpp	text/x-c++	8.74 KB	0644	2025-09-16 04:56:08
shared_lock_guard.hpp	text/x-c++	1.16 KB	0644	2025-09-16 04:56:08
shared_mutex.hpp	text/x-c++	1.37 KB	0644	2025-09-16 04:56:08
strict_lock.hpp	text/x-c++	6.1 KB	0644	2025-09-16 04:56:08
sync_bounded_queue.hpp	text/x-c	595 B	0644	2025-09-16 04:56:08
sync_queue.hpp	text/x-c	571 B	0644	2025-09-16 04:56:08
synchronized_value.hpp	text/x-c++	30.42 KB	0644	2025-09-16 04:56:08
testable_mutex.hpp	text/x-c++	3.83 KB	0644	2025-09-16 04:56:08
thread.hpp	text/x-c	385 B	0644	2025-09-16 04:56:08
thread_functors.hpp	text/x-c++	1.33 KB	0644	2025-09-16 04:56:08
thread_guard.hpp	text/x-c++	1.27 KB	0644	2025-09-16 04:56:08
thread_only.hpp	text/x-c	803 B	0644	2025-09-16 04:56:08
thread_pool.hpp	text/x-c	531 B	0644	2025-09-16 04:56:08
thread_time.hpp	text/x-c++	1.55 KB	0644	2025-09-16 04:56:08
tss.hpp	text/x-c++	2.54 KB	0644	2025-09-16 04:56:08
user_scheduler.hpp	text/x-c++	5.1 KB	0644	2025-09-16 04:56:08
with_lock_guard.hpp	text/x-c++	5.91 KB	0644	2025-09-16 04:56:08
xtime.hpp	text/x-c++	2.33 KB	0644	2025-09-16 04:56:08