proxygen: folly::basic_once_flag< Mutex, Atom

#include <CallOnce.h>

Public Member Functions
constexpr	basic_once_flag () noexcept=default

	basic_once_flag (const basic_once_flag &)=delete

basic_once_flag &	operator= (const basic_once_flag &)=delete

Private Member Functions
template<typename F , typename... Args>
FOLLY_ALWAYS_INLINE void	call_once (F &&f, Args &&...args)

template<typename F , typename... Args>
FOLLY_NOINLINE void	call_once_slow (F &&f, Args &&...args)

Private Attributes
Atom< bool >	called_ {false}

Mutex	mutex_

Friends
template<typename Mutex_ , template< typename > class Atom_, typename F , typename... Args>
void	call_once (basic_once_flag< Mutex_, Atom_ > &, F &&, Args &&...)

Detailed Description

template<typename Mutex, template< typename > class Atom>
class folly::basic_once_flag< Mutex, Atom >

Definition at line 31 of file CallOnce.h.

Constructor & Destructor Documentation

template<typename Mutex, template< typename > class Atom>

constexpr folly::basic_once_flag< Mutex, Atom >::basic_once_flag ( )

defaultnoexcept

Referenced by folly::call_once().

template<typename Mutex, template< typename > class Atom>

folly::basic_once_flag< Mutex, Atom >::basic_once_flag ( const basic_once_flag< Mutex, Atom > & )

delete

Member Function Documentation

template<typename Mutex, template< typename > class Atom>

template<typename F , typename... Args>

FOLLY_ALWAYS_INLINE void folly::basic_once_flag< Mutex, Atom >::call_once	(	F &&	f,
		Args &&...	args
	)

inlineprivate

Definition at line 81 of file CallOnce.h.

                                                             {
     if (LIKELY(called_.load(std::memory_order_acquire))) {
       return;
     }
     call_once_slow(std::forward<F>(f), std::forward<Args>(args)...);
   }

template<typename Mutex, template< typename > class Atom>

template<typename F , typename... Args>

FOLLY_NOINLINE void folly::basic_once_flag< Mutex, Atom >::call_once_slow	(	F &&	f,
		Args &&...	args
	)

inlineprivate

Definition at line 89 of file CallOnce.h.

Referenced by folly::basic_once_flag< SharedMutex >::call_once().

                                                             {
     std::lock_guard<Mutex> lock(mutex_);
     if (called_.load(std::memory_order_relaxed)) {
       return;
     }
     invoke(std::forward<F>(f), std::forward<Args>(args)...);
     called_.store(true, std::memory_order_release);
   }