folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT > Struct Template Reference

#include <AtomicBatchDispatcher-inl.h>

Classes
struct	Entry

Public Member Functions
	DispatchBaton (DispatchFunctionT &&dispatchFunction)
	~DispatchBaton ()
void	reserve (size_t numEntries)
void	setExceptionWrapper (folly::exception_wrapper &&exWrapper)
void	setExpectedCount (size_t expectedCount)
Future< ResultT >	getFutureResult (InputT &&input, size_t sequenceNumber)

Private Member Functions
void	setExceptionResults (const folly::exception_wrapper &exceptionWrapper)
void	setExceptionResults (std::exception_ptr eptr)
template<typename TException >
void	setExceptionResults (const TException &ex, std::exception_ptr eptr=std::exception_ptr())
void	fulfillPromises ()

Private Attributes
size_t	expectedCount_
DispatchFunctionT	dispatchFunction_
std::vector< folly::Optional< Entry > >	optEntries_
folly::exception_wrapper	exceptionWrapper_

Detailed Description

template<typename InputT, typename ResultT>
template<typename InputT, typename ResultT>
struct folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >

Definition at line 20 of file AtomicBatchDispatcher-inl.h.

Constructor & Destructor Documentation

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::DispatchBaton ( DispatchFunctionT &&  dispatchFunction )

inline

Definition at line 21 of file AtomicBatchDispatcher-inl.h.

      : expectedCount_(0), dispatchFunction_(std::move(dispatchFunction)) {}

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::~DispatchBaton ( )

inline

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

                   {
    fulfillPromises();
  }

Member Function Documentation

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

void folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::fulfillPromises ( )

inlineprivate

Definition at line 75 of file AtomicBatchDispatcher-inl.h.

References folly::fibers::detail::createABDTokenNotDispatchedExMsg(), folly::fibers::detail::createUnexpectedNumResultsABDUsageExMsg(), i, and folly::gen::move.

                         {
    try {
      // If an error message is set, set all promises to exception with message
      if (exceptionWrapper_) {
        return setExceptionResults(exceptionWrapper_);
      }

      // Validate entries count same as expectedCount_
      assert(
          optEntries_.size() == expectedCount_ ||
          !"Entries vector did not have expected size");
      std::vector<size_t> vecTokensNotDispatched;
      for (size_t i = 0; i < expectedCount_; ++i) {
        if (!optEntries_[i]) {
          vecTokensNotDispatched.push_back(i);
        }
      }
      if (!vecTokensNotDispatched.empty()) {
        return setExceptionResults(ABDTokenNotDispatchedException(
            detail::createABDTokenNotDispatchedExMsg(vecTokensNotDispatched)));
      }

      // Create the inputs vector
      std::vector<InputT> inputs;
      inputs.reserve(expectedCount_);
      for (auto& optEntry : optEntries_) {
        inputs.emplace_back(std::move(optEntry->input));
      }

      // Call the user provided batch dispatch function to get all results
      // and make sure that we have the expected number of results returned
      auto results = dispatchFunction_(std::move(inputs));
      if (results.size() != expectedCount_) {
        return setExceptionResults(
            ABDUsageException(detail::createUnexpectedNumResultsABDUsageExMsg(
                expectedCount_, results.size())));
      }

      // Fulfill the promises with the results from the batch dispatch
      for (size_t i = 0; i < expectedCount_; ++i) {
        optEntries_[i]->promise.setValue(std::move(results[i]));
      }
    } catch (const std::exception& ex) {
      // Set exceptions thrown when executing the user provided dispatch func
      return setExceptionResults(ex, std::current_exception());
    } catch (...) {
      // Set exceptions thrown when executing the user provided dispatch func
      return setExceptionResults(std::current_exception());
    }
  }

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

Future<ResultT> folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::getFutureResult ( InputT &&  input, size_t  sequenceNumber  )

inline

Definition at line 42 of file AtomicBatchDispatcher-inl.h.

References folly::gen::move.

                                                                         {
    if (sequenceNumber >= optEntries_.size()) {
      optEntries_.resize(sequenceNumber + 1);
    }
    folly::Optional<Entry>& optEntry = optEntries_[sequenceNumber];
    assert(!optEntry || !"Multiple inputs have the same token sequence number");
    optEntry = Entry(std::move(input));
    return optEntry->promise.getFuture();
  }

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

void folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::reserve ( size_t  numEntries )

inline

Definition at line 28 of file AtomicBatchDispatcher-inl.h.

                                  {
    optEntries_.reserve(numEntries);
  }

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

void folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::setExceptionResults ( const folly::exception_wrapper &  exceptionWrapper )

inlineprivate

Definition at line 53 of file AtomicBatchDispatcher-inl.h.

                                                                           {
    for (auto& optEntry : optEntries_) {
      if (optEntry) {
        optEntry->promise.setException(exceptionWrapper);
      }
    }
  }

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

void folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::setExceptionResults ( std::exception_ptr  eptr )

inlineprivate

Definition at line 61 of file AtomicBatchDispatcher-inl.h.

                                                  {
    auto exceptionWrapper = exception_wrapper(eptr);
    return setExceptionResults(exceptionWrapper);
  }

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

template<typename TException >

void folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::setExceptionResults ( const TException &  ex, std::exception_ptr  eptr = std::exception_ptr()  )

inlineprivate

Definition at line 67 of file AtomicBatchDispatcher-inl.h.

                                                  {
    auto exceptionWrapper =
        eptr ? exception_wrapper(eptr, ex) : exception_wrapper(ex);
    return setExceptionResults(exceptionWrapper);
  }

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

void folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::setExceptionWrapper ( folly::exception_wrapper &&  exWrapper )

inline

Definition at line 32 of file AtomicBatchDispatcher-inl.h.

References folly::gen::move.

                                                               {
    exceptionWrapper_ = std::move(exWrapper);
  }

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

void folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::setExpectedCount ( size_t  expectedCount )

inline

Definition at line 36 of file AtomicBatchDispatcher-inl.h.

                                              {
    assert(expectedCount_ == 0 || !"expectedCount_ being set more than once");
    expectedCount_ = expectedCount;
    optEntries_.resize(expectedCount_);
  }

Member Data Documentation

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

DispatchFunctionT folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::dispatchFunction_

private

Definition at line 143 of file AtomicBatchDispatcher-inl.h.

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

folly::exception_wrapper folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::exceptionWrapper_

private

Definition at line 145 of file AtomicBatchDispatcher-inl.h.

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

size_t folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::expectedCount_

private

Definition at line 142 of file AtomicBatchDispatcher-inl.h.

template<typename InputT, typename ResultT>

template<typename InputT , typename ResultT >

std::vector<folly::Optional<Entry> > folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::DispatchBaton< InputT, ResultT >::optEntries_

private

Definition at line 144 of file AtomicBatchDispatcher-inl.h.

---

The documentation for this struct was generated from the following file:

• proxygen/folly/folly/fibers/AtomicBatchDispatcher-inl.h