folly::EventBaseLocal< T > Class Template Reference

#include <EventBase.h>

Inheritance diagram for folly::EventBaseLocal< T >:

Public Member Functions
	EventBaseLocal ()
T *	get (EventBase &evb)
void	emplace (EventBase &evb, T *ptr)
template<typename... Args>
void	emplace (EventBase &evb, Args &&...args)
template<typename... Args>
T &	getOrCreate (EventBase &evb, Args &&...args)
template<typename Func >
T &	getOrCreateFn (EventBase &evb, Func fn)
Public Member Functions inherited from folly::detail::EventBaseLocalBase
	EventBaseLocalBase ()
	~EventBaseLocalBase () override
void	erase (EventBase &evb)
void	onEventBaseDestruction (EventBase &evb) override
Public Member Functions inherited from folly::detail::EventBaseLocalBaseBase
virtual	~EventBaseLocalBaseBase ()=default

Additional Inherited Members
Protected Member Functions inherited from folly::detail::EventBaseLocalBase
void	setVoid (EventBase &evb, std::shared_ptr< void > &&ptr)
void *	getVoid (EventBase &evb)
Protected Attributes inherited from folly::detail::EventBaseLocalBase
folly::Synchronized< std::unordered_set< EventBase * > >	eventBases_
std::size_t	key_ {keyCounter_++}
Static Protected Attributes inherited from folly::detail::EventBaseLocalBase
static std::atomic< std::size_t >	keyCounter_ {0}

Detailed Description

template<typename T>
class folly::EventBaseLocal< T >

A storage abstraction for data that should be tied to an EventBase.

struct Foo { Foo(int a, int b); }; EventBaseLocal<Foo> myFoo; ... EventBase evb; myFoo.set(evb, new Foo(1, 2)); myFoo.set(evb, 1, 2); Foo* foo = myFoo.get(evb); myFoo.erase(evb); Foo& foo = myFoo.getOrCreate(evb, 1, 2); // ctor Foo& foo = myFoo.getOrCreate(evb, 1, 2); // no ctor myFoo.erase(evb); Foo& foo = myFoo.getOrCreateFn(evb, [] () { return new Foo(3, 4); })

The objects will be deleted when the EventBaseLocal or the EventBase is destructed (whichever comes first). All methods must be called from the EventBase thread.

The user is responsible for throwing away invalid references/ptrs returned by the get() method after set/erase is called. If shared ownership is needed, use a EventBaseLocal<shared_ptr<...>>.

Definition at line 68 of file EventBase.h.

Constructor & Destructor Documentation

template<typename T>

folly::EventBaseLocal< T >::EventBaseLocal ( )

inline

Definition at line 76 of file EventBaseLocal.h.

: EventBaseLocalBase() {}

Member Function Documentation

template<typename T>

void folly::EventBaseLocal< T >::emplace ( EventBase &  evb, T *  ptr  )

inline

Definition at line 82 of file EventBaseLocal.h.

References testing::Args(), folly::gen::move, and folly::detail::EventBaseLocalBase::setVoid().

Referenced by TEST().

                                       {
    std::shared_ptr<T> smartPtr(ptr);
    setVoid(evb, std::move(smartPtr));
  }

template<typename T>

template<typename... Args>

void folly::EventBaseLocal< T >::emplace ( EventBase &  evb, Args &&...  args  )

inline

Definition at line 88 of file EventBaseLocal.h.

References testing::Args(), and folly::detail::EventBaseLocalBase::setVoid().

                                               {
    auto smartPtr = std::make_shared<T>(std::forward<Args>(args)...);
    setVoid(evb, smartPtr);
  }

template<typename T>

T* folly::EventBaseLocal< T >::get ( EventBase &  evb )

inline

Definition at line 78 of file EventBaseLocal.h.

References folly::detail::EventBaseLocalBase::getVoid(), and folly::T.

Referenced by TEST().

                         {
    return static_cast<T*>(getVoid(evb));
  }

template<typename T>

template<typename... Args>

T& folly::EventBaseLocal< T >::getOrCreate ( EventBase &  evb, Args &&...  args  )

inline

Definition at line 94 of file EventBaseLocal.h.

References folly::detail::EventBaseLocalBase::getVoid(), folly::gen::move, ptr, folly::detail::EventBaseLocalBase::setVoid(), and folly::T.

Referenced by TEST().

                                                 {
    if (auto ptr = getVoid(evb)) {
      return *static_cast<T*>(ptr);
    }
    auto smartPtr = std::make_shared<T>(std::forward<Args>(args)...);
    auto& ref = *smartPtr;
    setVoid(evb, std::move(smartPtr));
    return ref;
  }

template<typename T>

template<typename Func >

T& folly::EventBaseLocal< T >::getOrCreateFn ( EventBase &  evb, Func  fn  )

inline

Definition at line 105 of file EventBaseLocal.h.

References folly::detail::EventBaseLocalBase::getVoid(), folly::gen::move, ptr, folly::detail::EventBaseLocalBase::setVoid(), and folly::T.

Referenced by TEST().

                                            {
    // If this looks like it's copy/pasted from above, that's because it is.
    // gcc has a bug (fixed in 4.9) that doesn't allow capturing variadic
    // params in a lambda.
    if (auto ptr = getVoid(evb)) {
      return *static_cast<T*>(ptr);
    }
    std::shared_ptr<T> smartPtr(fn());
    auto& ref = *smartPtr;
    setVoid(evb, std::move(smartPtr));
    return ref;
  }

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/io/async/EventBase.h
• proxygen/folly/folly/io/async/EventBaseLocal.h