folly::observer::Observer< T > Class Template Reference

#include <Observer.h>

Public Member Functions
	Observer (observer_detail::Core::Ptr core)
Snapshot< T >	getSnapshot () const
Snapshot< T >	operator* () const
bool	needRefresh (const Snapshot< T > &snapshot) const
CallbackHandle	addCallback (folly::Function< void(Snapshot< T >)> callback) const

Private Attributes
observer_detail::Core::Ptr	core_

Friends
template<typename Observable , typename Traits >
class	ObserverCreator

Detailed Description

template<typename T>
class folly::observer::Observer< T >

Observer - a library which lets you create objects which track updates of their dependencies and get re-computed when any of the dependencies changes.

Given an Observer, you can get a snapshot of the current version of the object it holds:

Observer<int> myObserver = ...; Snapshot<int> mySnapshot = myObserver.getSnapshot(); or simply Snapshot<int> mySnapshot = *myObserver;

Snapshot will hold a view of the object, even if object in the Observer gets updated.

What makes Observer powerful is its ability to track updates to other Observers. Imagine we have two separate Observers A and B which hold integers.

Observer<int> observerA = ...; Observer<int> observerB = ...;

To compute a sum of A and B we can create a new Observer which would track updates to A and B and re-compute the sum only when necessary.

Observer<int> sumObserver = makeObserver( [observerA, observerB] { int a = **observerA; int b = **observerB; return a + b; });

int sum = **sumObserver;

Notice that a + b will be only called when either a or b is changed. Getting a snapshot from sumObserver won't trigger any re-computation.

TLObserver is very similar to Observer, but it also keeps a thread-local cache for the observed object.

Observer<int> observer = ...; TLObserver<int> tlObserver(observer); auto& snapshot = *tlObserver;

See ObserverCreator class if you want to wrap any existing subscription API in an Observer object.

Definition at line 77 of file Observer.h.

Constructor & Destructor Documentation

template<typename T >

folly::observer::Observer< T >::Observer ( observer_detail::Core::Ptr  core )

explicit

Definition at line 33 of file Observer-inl.h.

    : core_(std::move(core)) {}

Member Function Documentation

template<typename T >

CallbackHandle folly::observer::Observer< T >::addCallback

(

folly::Function< void(Snapshot< T >)>

callback

)

const

Definition at line 114 of file Observer-inl.h.

References folly::gen::move.

                                                     {
  return CallbackHandle(*this, std::move(callback));
}

template<typename T >

Snapshot< T > folly::observer::Observer< T >::getSnapshot

(

)

const

Definition at line 24 of file Observer-inl.h.

References folly::data(), folly::gen::move, and folly::T.

                                           {
  auto data = core_->getData();
  return Snapshot<T>(
      *core_,
      std::static_pointer_cast<const T>(std::move(data.data)),
      data.version);
}

template<typename T>

bool folly::observer::Observer< T >::needRefresh ( const Snapshot< T > &  snapshot ) const

inline

Check if we have a newer version of the observed object than the snapshot. Snapshot should have been originally from this Observer.

Definition at line 160 of file Observer.h.

References folly::observer::Snapshot< T >::core_, folly::observer::Snapshot< T >::getVersion(), and folly::observer_detail::Core::getVersionLastChange().

                                                      {
    DCHECK_EQ(core_.get(), snapshot.core_);
    return snapshot.getVersion() < core_->getVersionLastChange();
  }

template<typename T>

Snapshot<T> folly::observer::Observer< T >::operator* ( ) const

inline

Definition at line 152 of file Observer.h.

                                {
    return getSnapshot();
  }

Friends And Related Function Documentation

template<typename T>

template<typename Observable , typename Traits >

friend class ObserverCreator

friend

Definition at line 169 of file Observer.h.

Member Data Documentation

template<typename T>

observer_detail::Core::Ptr folly::observer::Observer< T >::core_

private

Definition at line 171 of file Observer.h.

---

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

• proxygen/folly/folly/experimental/observer/Observer.h
• proxygen/folly/folly/experimental/observer/Observer-inl.h